Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions/BinaryExpr.cs

@@ -0,0 +1,98 @@
+// 
+// BinaryExpr.cs
+// 
+// Authors:
+//	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.AST;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions {
+	class BinaryExpr<TSymbolicValue> : Expr<TSymbolicValue>
+		where TSymbolicValue : IEquatable<TSymbolicValue> {
+		
+		public readonly BinaryOperator Operator;
+		public readonly TSymbolicValue Left;
+		public readonly TSymbolicValue Right;
+
+		public BinaryExpr (TSymbolicValue left, TSymbolicValue right, BinaryOperator op)
+		{
+			this.Left = left;
+			this.Right = right;
+			this.Operator = op;
+		}
+
+		#region Overrides of Expression
+		public override IEnumerable<TSymbolicValue> Variables
+		{
+			get
+			{
+				yield return this.Left;
+				yield return this.Right;
+			}
+		}
+
+		public override Result Decode<Data, Result, Visitor> (APC pc, TSymbolicValue dest, Visitor visitor, Data data)
+		{
+			return visitor.Binary (pc, this.Operator, dest, this.Left, this.Right, data);
+		}
+
+		public override Expr<TSymbolicValue> Substitute (IImmutableMap<TSymbolicValue, Sequence<TSymbolicValue>> substitutions)
+		{
+			if (substitutions.ContainsKey (this.Left) && substitutions.ContainsKey (this.Right))
+				return new BinaryExpr<TSymbolicValue> (substitutions [this.Left].Head, substitutions [this.Right].Head, this.Operator);
+
+			return null;
+		}
+
+		public override bool IsContained (IImmutableSet<TSymbolicValue> candidates)
+		{
+			return candidates.Contains (this.Left) || candidates.Contains (this.Right);
+		}
+
+		public override bool Contains (TSymbolicValue symbol)
+		{
+			return this.Left.Equals (symbol) || this.Right.Equals (symbol);
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("Binary({0} {1} {2})", this.Left, this.Operator, this.Right);
+		}
+
+		public override bool Equals (Expr<TSymbolicValue> other)
+		{
+			var binary = other as BinaryExpr<TSymbolicValue>;
+			if (binary == null || binary.Operator != this.Operator)
+				return false;
+
+			return binary.Left.Equals (this.Left) && binary.Right.Equals (this.Right);
+		}
+		#endregion
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions/ConstExpr.cs

@@ -0,0 +1,85 @@
+// 
+// ConstExpr.cs
+// 
+// Authors:
+//	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.AST;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions {
+	class ConstExpr<TSymbolicValue> : Expr<TSymbolicValue> where TSymbolicValue : IEquatable<TSymbolicValue> {
+		public readonly TypeNode Type;
+		public readonly object value;
+
+		public ConstExpr (TypeNode type, object value)
+		{
+			this.Type = type;
+			this.value = value;
+		}
+
+		#region Overrides of Expression
+		public override IEnumerable<TSymbolicValue> Variables
+		{
+			get { yield break; }
+		}
+
+		public override Result Decode<Data, Result, Visitor> (APC pc, TSymbolicValue dest, Visitor visitor, Data data)
+		{
+			return visitor.LoadConst (pc, this.Type, this.value, dest, data);
+		}
+
+		public override Expr<TSymbolicValue> Substitute (IImmutableMap<TSymbolicValue, Sequence<TSymbolicValue>> substitutions)
+		{
+			return this;
+		}
+
+		public override bool IsContained (IImmutableSet<TSymbolicValue> candidates)
+		{
+			return false;
+		}
+
+		public override bool Contains (TSymbolicValue symbol)
+		{
+			return false;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("Const({0} {1})", this.Type, this.value);
+		}
+
+		public override bool Equals (Expr<TSymbolicValue> other)
+		{
+			var constant = other as ConstExpr<TSymbolicValue>;
+
+			return constant != null && constant.Type.Equals (this.Type) && constant.value.Equals (this.value);
+		}
+		#endregion
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions/Expr.cs

@@ -0,0 +1,57 @@
+// 
+// Expr.cs
+// 
+// Authors:
+//	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.AST.Visitors;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions {
+	abstract class Expr<TSymbolicValue> : IEquatable<Expr<TSymbolicValue>>
+		where TSymbolicValue : IEquatable<TSymbolicValue> {
+		
+		public abstract IEnumerable<TSymbolicValue> Variables { get; }
+
+		public abstract bool Equals (Expr<TSymbolicValue> other);
+
+		public abstract Result Decode<Data, Result, Visitor> (APC pc, TSymbolicValue dest, Visitor visitor, Data data)
+			where Visitor : IExpressionILVisitor<APC, TSymbolicValue, TSymbolicValue, Data, Result>;
+
+		public abstract Expr<TSymbolicValue> Substitute (IImmutableMap<TSymbolicValue, Sequence<TSymbolicValue>> substitutions);
+
+		/// <summary>
+		/// Specifies that current expression is partially contained in candidates
+		/// </summary>
+		public abstract bool IsContained (IImmutableSet<TSymbolicValue> candidates);
+
+		public abstract bool Contains (TSymbolicValue symbol);
+
+		public abstract override string ToString ();
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions/IsInstExpr.cs

@@ -0,0 +1,87 @@
+// 
+// IsInstExpr.cs
+// 
+// Authors:
+//	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.AST;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions {
+	class IsInstExpr<TSymbolicValue> : Expr<TSymbolicValue> where TSymbolicValue : IEquatable<TSymbolicValue> {
+		public readonly TSymbolicValue Argument;
+		public readonly TypeNode Type;
+
+		public IsInstExpr (TSymbolicValue argument, TypeNode type)
+		{
+			this.Argument = argument;
+			this.Type = type;
+		}
+
+		#region Overrides of Expression
+		public override IEnumerable<TSymbolicValue> Variables
+		{
+			get { yield return this.Argument; }
+		}
+
+		public override Result Decode<Data, Result, Visitor> (APC pc, TSymbolicValue dest, Visitor visitor, Data data)
+		{
+			return visitor.Isinst (pc, this.Type, dest, this.Argument, data);
+		}
+
+		public override Expr<TSymbolicValue> Substitute (IImmutableMap<TSymbolicValue, Sequence<TSymbolicValue>> substitutions)
+		{
+			if (substitutions.ContainsKey (this.Argument))
+				return new IsInstExpr<TSymbolicValue> (substitutions [this.Argument].Head, this.Type);
+			return null;
+		}
+
+		public override bool IsContained (IImmutableSet<TSymbolicValue> candidates)
+		{
+			return candidates.Contains (this.Argument);
+		}
+
+		public override bool Contains (TSymbolicValue symbol)
+		{
+			return this.Argument.Equals (symbol);
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ((string) "IsInst({0} {1})", (object) this.Type, (object) this.Argument);
+		}
+
+		public override bool Equals (Expr<TSymbolicValue> other)
+		{
+			var inst = other as IsInstExpr<TSymbolicValue>;
+
+			return (inst != null && inst.Type.Equals (this.Type) && inst.Argument.Equals (this.Argument));
+		}
+		#endregion
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions/NullExpr.cs

@@ -0,0 +1,79 @@
+// 
+// NullExpr.cs
+// 
+// Authors:
+//	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions {
+	sealed class NullExpr<TSymbolicValue> : Expr<TSymbolicValue> where TSymbolicValue : IEquatable<TSymbolicValue> {
+		public static readonly Expr<TSymbolicValue> Instance = new NullExpr<TSymbolicValue> ();
+
+		private NullExpr ()
+		{
+		}
+
+		#region Overrides of Expression
+		public override IEnumerable<TSymbolicValue> Variables
+		{
+			get { yield break; }
+		}
+
+		public override Result Decode<Data, Result, Visitor> (APC pc, TSymbolicValue dest, Visitor visitor, Data data)
+		{
+			return visitor.LoadNull (pc, dest, data);
+		}
+
+		public override Expr<TSymbolicValue> Substitute (IImmutableMap<TSymbolicValue, Sequence<TSymbolicValue>> substitutions)
+		{
+			return this;
+		}
+
+		public override bool IsContained (IImmutableSet<TSymbolicValue> candidates)
+		{
+			return false;
+		}
+
+		public override bool Contains (TSymbolicValue symbol)
+		{
+			return false;
+		}
+
+		public override string ToString ()
+		{
+			return "Null()";
+		}
+
+		public override bool Equals (Expr<TSymbolicValue> other)
+		{
+			return other == this;
+		}
+		#endregion
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions/SizeOfExpr.cs

@@ -0,0 +1,85 @@
+// 
+// SizeoOfExpr.cs
+// 
+// Authors:
+//	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Mono.CodeContracts.Static.AST;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions {
+	sealed class SizeOfExpr<TSymbolicValue> : Expr<TSymbolicValue> where TSymbolicValue : IEquatable<TSymbolicValue> {
+
+		public readonly TypeNode Type;
+
+		public SizeOfExpr (TypeNode type)
+		{
+			this.Type = type;
+		}
+
+		#region Overrides of Expression
+		public override IEnumerable<TSymbolicValue> Variables
+		{
+			get { return Enumerable.Empty<TSymbolicValue> (); }
+		}
+
+		public override Result Decode<Data, Result, Visitor> (APC pc, TSymbolicValue dest, Visitor visitor, Data data)
+		{
+			return visitor.Sizeof (pc, this.Type, dest, data);
+		}
+
+		public override Expr<TSymbolicValue> Substitute (IImmutableMap<TSymbolicValue, Sequence<TSymbolicValue>> substitutions)
+		{
+			return this;
+		}
+
+		public override bool IsContained (IImmutableSet<TSymbolicValue> candidates)
+		{
+			return false;
+		}
+
+		public override bool Contains (TSymbolicValue symbol)
+		{
+			return false;
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("Sizeof({0})", this.Type);
+		}
+
+		public override bool Equals (Expr<TSymbolicValue> other)
+		{
+			var @sizeof = other as SizeOfExpr<TSymbolicValue>;
+
+			return (@sizeof != null && @sizeof.Type.Equals (this.Type));
+		}
+		#endregion
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions/UnaryExpr.cs

@@ -0,0 +1,92 @@
+// 
+// UnaryExpr.cs
+// 
+// Authors:
+//	Alexander Chebaturkin (chebaturkin@gmail.com)
+// 
+// Copyright (C) 2011 Alexander Chebaturkin
+// 
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//  
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+using Mono.CodeContracts.Static.AST;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.DataStructures;
+
+namespace Mono.CodeContracts.Static.Analysis.ExpressionAnalysis.Expressions {
+	class UnaryExpr<TSymbolicValue> : Expr<TSymbolicValue> where TSymbolicValue : IEquatable<TSymbolicValue> {
+		public readonly UnaryOperator Operator;
+		public readonly TSymbolicValue Source;
+		public readonly bool Unsigned;
+
+		public UnaryExpr (TSymbolicValue source, UnaryOperator op, bool unsigned)
+		{
+			this.Source = source;
+			this.Operator = op;
+			this.Unsigned = unsigned;
+		}
+
+		#region Overrides of Expression
+		public override IEnumerable<TSymbolicValue> Variables
+		{
+			get { yield return this.Source; }
+		}
+
+		public override Result Decode<Data, Result, Visitor> (APC pc, TSymbolicValue dest, Visitor visitor, Data data)
+		{
+			return visitor.Unary (pc, this.Operator, this.Unsigned, dest, this.Source, data);
+		}
+
+		public override Expr<TSymbolicValue> Substitute (IImmutableMap<TSymbolicValue, Sequence<TSymbolicValue>> substitutions)
+		{
+			if (substitutions.ContainsKey (this.Source))
+				return new UnaryExpr<TSymbolicValue> (substitutions [this.Source].Head, this.Operator, this.Unsigned);
+			
+			return null;
+		}
+
+		public override bool IsContained (IImmutableSet<TSymbolicValue> candidates)
+		{
+			return candidates.Contains (this.Source);
+		}
+
+		public override bool Contains (TSymbolicValue symbol)
+		{
+			return symbol.Equals (this.Source);
+		}
+
+		public override string ToString ()
+		{
+			return String.Format ("Unary({0} {1})", this.Operator, this.Source);
+		}
+
+		public override bool Equals (Expr<TSymbolicValue> other)
+		{
+			var unary = other as UnaryExpr<TSymbolicValue>;
+			if (unary == null || unary.Operator != this.Operator || unary.Unsigned != this.Unsigned)
+				return false;
+
+			return unary.Source.Equals (this.Source);
+		}
+		#endregion
+	}
+}