Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static/CheckOptions.cs

@@ -0,0 +1,44 @@
+// 
+// CheckOptions.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.
+// 
+
+namespace Mono.CodeContracts.Static {
+	public class CheckOptions {
+		public CheckOptions ()
+		{
+		}
+
+		public string Assembly { get; set; }
+		/// <summary>
+		/// Method name constraint
+		/// If specified, check is performed only on methods containing this name as substring
+		/// </summary>
+		public string Method { get; set; }
+
+		public bool ShowDebug { get; set; }
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static/CheckResults.cs

@@ -0,0 +1,68 @@
+// 
+// CheckResults.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.Collections.Generic;
+using System.Linq;
+
+namespace Mono.CodeContracts.Static {
+	public class CheckResults {
+		private readonly ICollection<string> warnings;
+		private readonly ICollection<string> errors;
+		private readonly IDictionary<string, ICollection<string>> checker_messages; 
+
+		internal static CheckResults Error(string warning)
+		{
+			return new CheckResults (new[] {warning}, null, null);
+		}
+
+		internal CheckResults (ICollection<string> warnings, ICollection<string> errors, IDictionary<string, ICollection<string>> checkerMessages)
+		{
+			this.warnings = warnings;
+			this.errors = errors;
+			this.checker_messages = checkerMessages;
+		}
+
+		public bool AnyWarnings { get { return this.warnings != null && this.warnings.Count > 0; }}
+		public bool AnyErrors { get { return this.errors != null && this.errors.Count > 0; } }
+
+		public IEnumerable<string> Warnings
+		{
+			get { return this.warnings ?? Enumerable.Empty<string> (); }
+		}
+
+		public IEnumerable<string> Errors
+		{
+			get { return this.errors ?? Enumerable.Empty<string> (); }
+		}
+
+		public IDictionary<string, ICollection<string>> Results
+		{
+			get { return this.checker_messages ?? null; }
+		}
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static/Checker.cs

@@ -0,0 +1,141 @@
+// 
+// Checker.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.Analysis.Drivers;
+using Mono.CodeContracts.Static.Analysis.HeapAnalysis;
+using Mono.CodeContracts.Static.Analysis.NonNull;
+using Mono.CodeContracts.Static.Analysis.Numerical;
+using Mono.CodeContracts.Static.ControlFlow;
+using Mono.CodeContracts.Static.Providers;
+using Mono.CodeContracts.Static.Proving;
+
+namespace Mono.CodeContracts.Static {
+	public class Checker {
+		private readonly CheckOptions options;
+		private CodeContractsAnalysisDriver<IMethodResult<SymbolicValue>> analysis_driver;
+		private Dictionary<string, IMethodAnalysis> analyzers;
+
+		private Checker (CheckOptions options)
+		{
+			this.options = options;
+		}
+
+		public static CheckResults Check (CheckOptions options)
+		{
+			var checker = new Checker (options);
+			return checker.Analyze ();
+		}
+
+		private CheckResults Analyze ()
+		{
+			if (this.options.Assembly == null)
+				return CheckResults.Error ("No assembly given to check");
+
+			DebugOptions.Debug = this.options.ShowDebug;
+
+		        this.analyzers = new Dictionary<string, IMethodAnalysis> {
+		                {"non-null", new NonNullAnalysisFacade ()},
+		                {"arithmetic", new Analysers.Arithmetic ()}
+		        };
+
+			this.analysis_driver = new CodeContractsAnalysisDriver<IMethodResult<SymbolicValue>> (
+				new BasicAnalysisDriver (MetaDataProvider.Instance, CodeContractDecoder.Instance));
+
+			return AnalyzeAssembly (this.options.Assembly);
+		}
+
+		private CheckResults AnalyzeAssembly (string assemblyPath)
+		{
+			IMetaDataProvider metadataDecoder = this.analysis_driver.MetaDataProvider;
+			AssemblyNode assembly;
+			string reason;
+			if (!metadataDecoder.TryLoadAssembly (assemblyPath, out assembly, out reason))
+				return CheckResults.Error (string.Format ("Cannot load assembly: {0}", reason));
+
+			var proofResults = new Dictionary<string, ICollection<string>> ();
+			foreach (Method method in metadataDecoder.Methods (assembly))
+				AnalyzeMethod (method, proofResults);
+			if (proofResults.Count == 0)
+				return CheckResults.Error ("No methods found.");
+
+			return new CheckResults (null, null, proofResults);
+		}
+
+		private void AnalyzeMethod (Method method, Dictionary<string, ICollection<string>> proofResults)
+		{
+			IMetaDataProvider metadataDecoder = this.analysis_driver.MetaDataProvider;
+			if (!metadataDecoder.HasBody (method))
+				return;
+			if (this.options.Method != null && !metadataDecoder.FullName (method).Contains (this.options.Method))
+				return;
+
+			var results = new List<string> ();
+			proofResults.Add (method.FullName, results);
+			try {
+				AnalyzeMethodInternal (method, results);
+			} catch (Exception e) {
+				results.Add ("Exception: " + e.Message);
+				return;
+			}
+
+			results.Add (string.Format ("Checked {0} assertions", results.Count));
+		}
+
+		private void AnalyzeMethodInternal (Method method, List<string> proofResults)
+		{
+			string fullMethodName = method.FullName;
+			IMethodDriver<LabeledSymbol<APC, SymbolicValue>, SymbolicValue> methodDriver = this.analysis_driver.CreateMethodDriver (method);
+
+			methodDriver.RunHeapAndExpressionAnalyses ();
+
+			var results = new List<IMethodResult<SymbolicValue>> (this.analyzers.Values.Count);
+			foreach (IMethodAnalysis analysis in this.analyzers.Values) {
+				IMethodResult<SymbolicValue> result = analysis.Analyze (fullMethodName, methodDriver);
+				results.Add (result);
+			}
+
+			ComposedFactQuery<SymbolicValue> facts = CreateFactQuery (methodDriver.BasicFacts.IsUnreachable, results);
+			foreach (var methodResult in results)
+				methodResult.ValidateImplicitAssertions (facts, proofResults);
+
+			AssertionFinder.ValidateAssertions (facts, methodDriver, proofResults);
+		}
+
+		private ComposedFactQuery<Variable> CreateFactQuery<Variable> (Predicate<APC> isUnreachable, IEnumerable<IMethodResult<Variable>> results)
+		{
+			var res = new ComposedFactQuery<Variable> (isUnreachable);
+			res.Add (new ConstantPropagationFactQuery<Variable> ());
+			foreach (var methodResult in results)
+				res.Add (methodResult.FactQuery);
+			return res;
+		}
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static/DebugOptions.cs

@@ -0,0 +1,33 @@
+// 
+// DebugOptions.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.
+// 
+
+namespace Mono.CodeContracts.Static {
+	static class DebugOptions {
+		public static bool Debug { get; set; }
+	}
+}

mcs/class/Mono.CodeContracts/Mono.CodeContracts.Static/ProofOutcome.cs

@@ -0,0 +1,71 @@
+// 
+// ProofOutcome.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.ComponentModel;
+
+using Mono.CodeContracts.Static.Lattices;
+
+namespace Mono.CodeContracts.Static {
+    static class ProofOutcome {
+        /// <summary>
+        /// Can be true or false.
+        /// </summary>
+        public static readonly FlatDomain<bool> Top = FlatDomain<bool>.TopValue;
+        /// <summary>
+        /// Unreachable.
+        /// </summary>
+        public static readonly FlatDomain<bool> Bottom = FlatDomain<bool>.BottomValue;
+        /// <summary>
+        /// Definitely true.
+        /// </summary>
+        public static readonly FlatDomain<bool> True = true;
+        /// <summary>
+        /// Definitely false.
+        /// </summary>
+        public static readonly FlatDomain<bool> False = false;
+
+        public static FlatDomain<bool> Negate(this FlatDomain<bool> o)
+        {
+            if (o.IsNormal())
+                return !o.IsTrue();
+
+            return o;
+        }
+
+        public static bool IsTrue(this FlatDomain<bool> o) 
+        {
+            return o.IsNormal () && o.Value;
+        }
+
+        public static bool IsFalse(this FlatDomain<bool> o)
+        {
+            return o.IsNormal () && !o.Value;
+        }
+    }
+}