Cosmetic: fix spelling; patch from David Mitchell

svn path=/trunk/mcs/; revision=71571

16 files changed, 76 insertions, 77 deletions

diff --git a/mcs/class/System.Data/System.Data/XmlDataInferenceLoader.cs b/mcs/class/System.Data/System.Data/XmlDataInferenceLoader.cs
index 93b858bdc71..30d47cf6aae 100644
--- a/mcs/class/System.Data/System.Data/XmlDataInferenceLoader.cs
+++ b/mcs/class/System.Data/System.Data/XmlDataInferenceLoader.cs
@@ -258,7 +258,7 @@ namespace System.Data
 				return;

 			}

 			if (table.ChildTables [localName] != null)

-				// Child is already mapped, or infered as a table

+				// Child is already mapped, or inferred as a table

 				// (in that case, that takes precedence than

 				// this simple column inference.)

 				return;

@@ -756,7 +756,7 @@ sw = Console.Out;
 //

 // *** Mapping strategy

 //

-//	Attributes are always (except for namespace nodes) infered as 

+//	Attributes are always (except for namespace nodes) inferred as 

 //	DataColumn (of MappingType.Attribute).

 //

 //	When an element has attributes, it always becomes a DataTable.

diff --git a/mcs/class/System.Data/System.Data/XmlDataLoader.cs b/mcs/class/System.Data/System.Data/XmlDataLoader.cs
index d1127b80be6..f46d853ffa0 100644
--- a/mcs/class/System.Data/System.Data/XmlDataLoader.cs
+++ b/mcs/class/System.Data/System.Data/XmlDataLoader.cs
@@ -281,8 +281,8 @@ namespace System.Data
 				// Elements that have attributes are inferred as tables. 
 				// Elements that have child elements are inferred as tables. 
 				// Elements that repeat are inferred as a single table. 
-				if (IsInferedAsTable(childNode)) {
-					// child node infered as table
+				if (IsInferredAsTable(childNode)) {
+					// child node inferred as table
 					if (inferSchema) {
 						// We need to create new column for the relation between the current
 						// table and the new table we found (the child table).
@@ -447,7 +447,7 @@ namespace System.Data
 			return (node.Attributes != null && node.Attributes.Count > 0);
 		}
 
-		private bool IsInferedAsTable(XmlNode node)
+		private bool IsInferredAsTable(XmlNode node)
 		{
 			// Elements that have attributes are inferred as tables. 
 			// Elements that have child elements are inferred as tables. 
diff --git a/mcs/class/System.XML/System.Xml.Schema/XmlSchemaInference.cs b/mcs/class/System.XML/System.Xml.Schema/XmlSchemaInference.cs
index 02ac9141f82..7ad7a3dd4f3 100644
--- a/mcs/class/System.XML/System.Xml.Schema/XmlSchemaInference.cs
+++ b/mcs/class/System.XML/System.Xml.Schema/XmlSchemaInference.cs
@@ -1003,7 +1003,7 @@ namespace System.Xml.Schema
 				return QNameString;
 
 			switch (value) {
-			// 0 and 1 are not infered as byte unlike MS.XSDInfer
+			// 0 and 1 are not inferred as byte unlike MS.XSDInfer
 //			case "0":
 //			case "1":
 			case "true":
diff --git a/mcs/class/System.XML/System.Xml.Schema/XmlSchemaInferenceDesign.txt b/mcs/class/System.XML/System.Xml.Schema/XmlSchemaInferenceDesign.txt
index 8af2a48dde3..691581b0c3d 100644
--- a/mcs/class/System.XML/System.Xml.Schema/XmlSchemaInferenceDesign.txt
+++ b/mcs/class/System.XML/System.Xml.Schema/XmlSchemaInferenceDesign.txt
@@ -65,7 +65,7 @@
 	For example, it keeps elementFormDefault and attributeFormDefault.
 
 	Basically it will process the XmlReader with existing XmlSchemaSet
-	and won't "merge" two XmlSchemaSets one of which is newly infered
+	and won't "merge" two XmlSchemaSets one of which is newly inferred
 	from this XmlReader. Because anyways the XmlReader will have to
 	infer sequential nodes (siblings).
 
@@ -142,10 +142,10 @@
 	<ul>
 		- If the content type was simpleType, then it is changed
 		  into complexType with complexContent and mixed='true'.
-		  The infered content particle must be optional.
+		  The inferred content particle must be optional.
 		- If the content type was empty, then it is changed into
 		  complexType with complexContent (it is not mixed unlike
-		  above). The infered content particle must be optional.
+		  above). The inferred content particle must be optional.
 		- If the content type was elementOnly or mixed, no need
 		  to change.
 	</ul>
@@ -181,7 +181,7 @@
 			  (none != empty).
 		</ul>
 
-		- When the target element is infered in a new element
+		- When the target element is inferred in a new element
 		  definition, then 
 	</ul>
 
@@ -284,7 +284,7 @@
 
 	(Actually inference is done from non post compilation information.)
 
-	Note that type relaxation happens only when it is infered as textOnly
+	Note that type relaxation happens only when it is inferred as textOnly
 	and it always occurs.
 
 
@@ -292,7 +292,7 @@
 
 ** Type inference
 
-	All data types are infered from string value; either element content
+	All data types are inferred from string value; either element content
 	or attribute value.
 
 
@@ -317,8 +317,8 @@
 		  related schema types.
 
 		- If if did not match any kind of predefined types, then
-		  xs:string is infered. No other string-based types (such
-		  as xs:token) are infered.
+		  xs:string is inferred. No other string-based types (such
+		  as xs:token) are inferred.
 	</ul>
 
 
@@ -337,7 +337,7 @@
 		  for unsignedShort
 	</ul>
 
-	Here, the new string value is infered into a simpleType, and then
+	Here, the new string value is inferred into a simpleType, and then
 	the processor will compute the most specific common type between
-	the existing type and the newly infered type.
+	the existing type and the newly inferred type.
 
diff --git a/mcs/class/System/Test/System/UriParserTest.cs b/mcs/class/System/Test/System/UriParserTest.cs
index 8dba8d1cb9b..b7ccfb79118 100644
--- a/mcs/class/System/Test/System/UriParserTest.cs
+++ b/mcs/class/System/Test/System/UriParserTest.cs
@@ -423,7 +423,7 @@ namespace MonoTests.System {
 			Assert.IsTrue (UriParser.IsKnownScheme ("net.tcp"), "net.tcp");
 			Assert.IsTrue (UriParser.IsKnownScheme ("news"), "news");
 			Assert.IsTrue (UriParser.IsKnownScheme ("nntp"), "nntp");
-			// infered from class library
+			// inferred from class library
 			Assert.IsTrue (UriParser.IsKnownScheme ("ldap"), "ldap");
 			Assert.IsFalse (UriParser.IsKnownScheme ("ldaps"), "ldaps");
 			// well known for not existing
diff --git a/mcs/errors/gcs0411-2.cs b/mcs/errors/gcs0411-2.cs
index 3cebd543739..c0ad3fd2839 100644
--- a/mcs/errors/gcs0411-2.cs
+++ b/mcs/errors/gcs0411-2.cs
@@ -1,4 +1,4 @@
-// gcs0411.cs: The type arguments for method `Foo' cannot be infered from the usage. Try specifying the type arguments explicitly
+// gcs0411.cs: The type arguments for method `Foo' cannot be inferred from the usage. Try specifying the type arguments explicitly
 // Line: 15
 
 class Test<A>
diff --git a/mcs/errors/gcs0411-3.cs b/mcs/errors/gcs0411-3.cs
index 9b2c9bf795f..bddfb57da99 100644
--- a/mcs/errors/gcs0411-3.cs
+++ b/mcs/errors/gcs0411-3.cs
@@ -1,4 +1,4 @@
-// gcs0411.cs: The type arguments for method `Foo' cannot be infered from the usage. Try specifying the type arguments explicitly
+// gcs0411.cs: The type arguments for method `Foo' cannot be inferred from the usage. Try specifying the type arguments explicitly
 // Line: 15
 
 class Test<A,B>
@@ -15,4 +15,3 @@ class X
 		test.Foo (test, test);
 	}
 }
-
diff --git a/mcs/errors/gcs0411-4.cs b/mcs/errors/gcs0411-4.cs
index d44de02b51e..91e555944d7 100644
--- a/mcs/errors/gcs0411-4.cs
+++ b/mcs/errors/gcs0411-4.cs
@@ -1,4 +1,4 @@
-// gcs0411.cs: The type arguments for method `T X.G<T>()' cannot be infered from the usage. Try specifying the type arguments explicitly
+// gcs0411.cs: The type arguments for method `T X.G<T>()' cannot be inferred from the usage. Try specifying the type arguments explicitly
 // Line: 17
 
 using System;
diff --git a/mcs/errors/gcs0411-5.cs b/mcs/errors/gcs0411-5.cs
index 50d7d61929c..da96b975112 100644
--- a/mcs/errors/gcs0411-5.cs
+++ b/mcs/errors/gcs0411-5.cs
@@ -1,4 +1,4 @@
-// CS0411: The type arguments for method `World' cannot be infered from the usage. Try specifying the type arguments explicitly
+// CS0411: The type arguments for method `World' cannot be inferred from the usage. Try specifying the type arguments explicitly
 // Line: 16
 public interface IFoo<T>
 { }
diff --git a/mcs/errors/gcs0411-6.cs b/mcs/errors/gcs0411-6.cs
index 67caa5a8a7f..9a137f1d17f 100644
--- a/mcs/errors/gcs0411-6.cs
+++ b/mcs/errors/gcs0411-6.cs
@@ -1,4 +1,4 @@
-// CS0411: The type arguments for method `World' cannot be infered from the usage. Try specifying the type arguments explicitly
+// CS0411: The type arguments for method `World' cannot be inferred from the usage. Try specifying the type arguments explicitly
 // Line: 16
 public interface IFoo<T>
 { }
diff --git a/mcs/errors/gcs0411-7.cs b/mcs/errors/gcs0411-7.cs
index 815602d5e6a..3ef7a7fc61a 100644
--- a/mcs/errors/gcs0411-7.cs
+++ b/mcs/errors/gcs0411-7.cs
@@ -1,4 +1,4 @@
-// CS0411: The type arguments for method `Test' cannot be infered from the usage. Try specifying the type arguments explicitly
+// CS0411: The type arguments for method `Test' cannot be inferred from the usage. Try specifying the type arguments explicitly
 // Line: 15
 using System;
 
diff --git a/mcs/errors/gcs0411.cs b/mcs/errors/gcs0411.cs
index 1b77817d0ff..f317707f1da 100644
--- a/mcs/errors/gcs0411.cs
+++ b/mcs/errors/gcs0411.cs
@@ -1,4 +1,4 @@
-// gcs0411.cs: The type arguments for method `Foo' cannot be infered from the usage. Try specifying the type arguments explicitly
+// gcs0411.cs: The type arguments for method `Foo' cannot be inferred from the usage. Try specifying the type arguments explicitly
 // Line: 15
 
 class Test<A>
diff --git a/mcs/gmcs/generic.cs b/mcs/gmcs/generic.cs
index 7b5f74c2e05..5a81309b45a 100644
--- a/mcs/gmcs/generic.cs
+++ b/mcs/gmcs/generic.cs
@@ -2095,8 +2095,8 @@ namespace Mono.CSharp {
 		///   Check whether `a' and `b' may become equal generic types.
 		///   The algorithm to do that is a little bit complicated.
 		/// </summary>
-		public static bool MayBecomeEqualGenericTypes (Type a, Type b, Type[] class_infered,
-							       Type[] method_infered)
+		public static bool MayBecomeEqualGenericTypes (Type a, Type b, Type[] class_inferred,
+							       Type[] method_inferred)
 		{
 			if (a.IsGenericParameter) {
 				//
@@ -2118,7 +2118,7 @@ namespace Mono.CSharp {
 				// 
 				if (b.IsGenericParameter || !b.IsGenericType) {
 					int pos = a.GenericParameterPosition;
-					Type[] args = a.DeclaringMethod != null ? method_infered : class_infered;
+					Type[] args = a.DeclaringMethod != null ? method_inferred : class_inferred;
 					if (args [pos] == null) {
 						args [pos] = b;
 						return true;
@@ -2150,7 +2150,7 @@ namespace Mono.CSharp {
 			}
 
 			if (b.IsGenericParameter)
-				return MayBecomeEqualGenericTypes (b, a, class_infered, method_infered);
+				return MayBecomeEqualGenericTypes (b, a, class_inferred, method_inferred);
 
 			//
 			// At this point, neither a nor b are a type parameter.
@@ -2162,7 +2162,7 @@ namespace Mono.CSharp {
 			//
 
 			if (a.IsGenericType || b.IsGenericType)
-				return MayBecomeEqualGenericInstances (a, b, class_infered, method_infered);
+				return MayBecomeEqualGenericInstances (a, b, class_inferred, method_inferred);
 
 			//
 			// If both of them are arrays.
@@ -2175,7 +2175,7 @@ namespace Mono.CSharp {
 				a = a.GetElementType ();
 				b = b.GetElementType ();
 
-				return MayBecomeEqualGenericTypes (a, b, class_infered, method_infered);
+				return MayBecomeEqualGenericTypes (a, b, class_inferred, method_inferred);
 			}
 
 			//
@@ -2190,8 +2190,8 @@ namespace Mono.CSharp {
 		// particular instantiation (26.3.1).
 		//
 		public static bool MayBecomeEqualGenericInstances (Type a, Type b,
-								   Type[] class_infered,
-								   Type[] method_infered)
+								   Type[] class_inferred,
+								   Type[] method_inferred)
 		{
 			if (!a.IsGenericType || !b.IsGenericType)
 				return false;
@@ -2199,18 +2199,18 @@ namespace Mono.CSharp {
 				return false;
 
 			return MayBecomeEqualGenericInstances (
-				GetTypeArguments (a), GetTypeArguments (b), class_infered, method_infered);
+				GetTypeArguments (a), GetTypeArguments (b), class_inferred, method_inferred);
 		}
 
 		public static bool MayBecomeEqualGenericInstances (Type[] aargs, Type[] bargs,
-								   Type[] class_infered,
-								   Type[] method_infered)
+								   Type[] class_inferred,
+								   Type[] method_inferred)
 		{
 			if (aargs.Length != bargs.Length)
 				return false;
 
 			for (int i = 0; i < aargs.Length; i++) {
-				if (!MayBecomeEqualGenericTypes (aargs [i], bargs [i], class_infered, method_infered))
+				if (!MayBecomeEqualGenericTypes (aargs [i], bargs [i], class_inferred, method_inferred))
 					return false;
 			}
 
@@ -2221,7 +2221,7 @@ namespace Mono.CSharp {
 		// Type inference.
 		//
 
-		static bool InferType (Type pt, Type at, Type[] infered)
+		static bool InferType (Type pt, Type at, Type[] inferred)
 		{
 			if (pt.IsGenericParameter) {
 				if (pt.DeclaringMethod == null)
@@ -2229,12 +2229,12 @@ namespace Mono.CSharp {
 
 				int pos = pt.GenericParameterPosition;
 
-				if (infered [pos] == null) {
-					infered [pos] = at;
+				if (inferred [pos] == null) {
+					inferred [pos] = at;
 					return true;
 				}
 
-				if (infered [pos] != at)
+				if (inferred [pos] != at)
 					return false;
 
 				return true;
@@ -2242,7 +2242,7 @@ namespace Mono.CSharp {
 
 			if (!pt.ContainsGenericParameters) {
 				if (at.ContainsGenericParameters)
-					return InferType (at, pt, infered);
+					return InferType (at, pt, inferred);
 				else
 					return true;
 			}
@@ -2252,7 +2252,7 @@ namespace Mono.CSharp {
 					if (at.GetArrayRank () != pt.GetArrayRank ())
 						return false;
 
-					return InferType (pt.GetElementType (), at.GetElementType (), infered);
+					return InferType (pt.GetElementType (), at.GetElementType (), inferred);
 				}
 
 				if (!pt.IsGenericType)
@@ -2264,7 +2264,7 @@ namespace Mono.CSharp {
 					return false;
 
 				Type[] args = GetTypeArguments (pt);
-				return InferType (args [0], at.GetElementType (), infered);
+				return InferType (args [0], at.GetElementType (), inferred);
 			}
 
 			if (pt.IsArray) {
@@ -2272,11 +2272,11 @@ namespace Mono.CSharp {
 				    (pt.GetArrayRank () != at.GetArrayRank ()))
 					return false;
 
-				return InferType (pt.GetElementType (), at.GetElementType (), infered);
+				return InferType (pt.GetElementType (), at.GetElementType (), inferred);
 			}
 
 			if (pt.IsByRef && at.IsByRef)
-				return InferType (pt.GetElementType (), at.GetElementType (), infered);
+				return InferType (pt.GetElementType (), at.GetElementType (), inferred);
 			ArrayList list = new ArrayList ();
 			if (at.IsGenericType)
 				list.Add (at);
@@ -2291,18 +2291,18 @@ namespace Mono.CSharp {
 				if (!type.IsGenericType)
 					continue;
 
-				Type[] infered_types = new Type [infered.Length];
+				Type[] inferred_types = new Type [inferred.Length];
 
-				if (!InferGenericInstance (pt, type, infered_types))
+				if (!InferGenericInstance (pt, type, inferred_types))
 					continue;
 
-				for (int i = 0; i < infered_types.Length; i++) {
-					if (infered [i] == null) {
-						infered [i] = infered_types [i];
+				for (int i = 0; i < inferred_types.Length; i++) {
+					if (inferred [i] == null) {
+						inferred [i] = inferred_types [i];
 						continue;
 					}
 
-					if (infered [i] != infered_types [i])
+					if (inferred [i] != inferred_types [i])
 						return false;
 				}
 
@@ -2312,7 +2312,7 @@ namespace Mono.CSharp {
 			return found_one;
 		}
 
-		static bool InferGenericInstance (Type pt, Type at, Type[] infered_types)
+		static bool InferGenericInstance (Type pt, Type at, Type[] inferred_types)
 		{
 			Type[] at_args = at.GetGenericArguments ();
 			Type[] pt_args = pt.GetGenericArguments ();
@@ -2321,12 +2321,12 @@ namespace Mono.CSharp {
 				return false;
 
 			for (int i = 0; i < at_args.Length; i++) {
-				if (!InferType (pt_args [i], at_args [i], infered_types))
+				if (!InferType (pt_args [i], at_args [i], inferred_types))
 					return false;
 			}
 
-			for (int i = 0; i < infered_types.Length; i++) {
-				if (infered_types [i] == null)
+			for (int i = 0; i < inferred_types.Length; i++) {
+				if (inferred_types [i] == null)
 					return false;
 			}
 
@@ -2363,7 +2363,7 @@ namespace Mono.CSharp {
 				return false;
 
 			Type[] method_args = method.GetGenericArguments ();
-			Type[] infered_types = new Type [method_args.Length];
+			Type[] inferred_types = new Type [method_args.Length];
 
 			//
 			// If we have come this far, the case which
@@ -2379,7 +2379,7 @@ namespace Mono.CSharp {
 				Type pt = pd.ParameterType (i);
 				Type at = a.Type;
 
-				if (!InferType (pt, at, infered_types))
+				if (!InferType (pt, at, inferred_types))
 					return false;
 			}
 
@@ -2391,34 +2391,34 @@ namespace Mono.CSharp {
 				if ((a.Expr is NullLiteral) || (a.Expr is MethodGroupExpr))
 					continue;
 
-				if (!InferType (element_type, a.Type, infered_types))
+				if (!InferType (element_type, a.Type, inferred_types))
 					return false;
 			}
 
-			for (int i = 0; i < infered_types.Length; i++)
-				if (infered_types [i] == null)
+			for (int i = 0; i < inferred_types.Length; i++)
+				if (inferred_types [i] == null)
 					return false;
 
-			method = ((MethodInfo)method).MakeGenericMethod (infered_types);
+			method = ((MethodInfo)method).MakeGenericMethod (inferred_types);
 			return true;
 		}
 
 		static bool InferTypeArguments (Type[] param_types, Type[] arg_types,
-						Type[] infered_types)
+						Type[] inferred_types)
 		{
-			if (infered_types == null)
+			if (inferred_types == null)
 				return false;
 
 			for (int i = 0; i < arg_types.Length; i++) {
 				if (arg_types [i] == null)
 					continue;
 
-				if (!InferType (param_types [i], arg_types [i], infered_types))
+				if (!InferType (param_types [i], arg_types [i], inferred_types))
 					return false;
 			}
 
-			for (int i = 0; i < infered_types.Length; i++)
-				if (infered_types [i] == null)
+			for (int i = 0; i < inferred_types.Length; i++)
+				if (inferred_types [i] == null)
 					return false;
 
 			return true;
@@ -2460,7 +2460,7 @@ namespace Mono.CSharp {
 			if (!is_open)
 				return !TypeManager.IsGenericMethodDefinition (method);
 
-			Type[] infered_types = new Type [method_args.Length];
+			Type[] inferred_types = new Type [method_args.Length];
 
 			Type[] param_types = new Type [pd.Count];
 			Type[] arg_types = new Type [pd.Count];
@@ -2476,10 +2476,10 @@ namespace Mono.CSharp {
 				arg_types [i] = a.Type;
 			}
 
-			if (!InferTypeArguments (param_types, arg_types, infered_types))
+			if (!InferTypeArguments (param_types, arg_types, inferred_types))
 				return false;
 
-			method = ((MethodInfo)method).MakeGenericMethod (infered_types);
+			method = ((MethodInfo)method).MakeGenericMethod (inferred_types);
 			return true;
 		}
 
@@ -2497,7 +2497,7 @@ namespace Mono.CSharp {
 				return false;
 
 			Type[] method_args = method.GetGenericArguments ();
-			Type[] infered_types = new Type [method_args.Length];
+			Type[] inferred_types = new Type [method_args.Length];
 
 			Type[] param_types = new Type [pd.Count];
 			Type[] arg_types = new Type [pd.Count];
@@ -2507,10 +2507,10 @@ namespace Mono.CSharp {
 				arg_types [i] = apd.ParameterType (i);
 			}
 
-			if (!InferTypeArguments (param_types, arg_types, infered_types))
+			if (!InferTypeArguments (param_types, arg_types, inferred_types))
 				return false;
 
-			method = ((MethodInfo)method).MakeGenericMethod (infered_types);
+			method = ((MethodInfo)method).MakeGenericMethod (inferred_types);
 			return true;
 		}
 	}
diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs
index c8d5aff7382..03a3ff518d1 100644
--- a/mcs/mcs/class.cs
+++ b/mcs/mcs/class.cs
@@ -1141,8 +1141,8 @@ namespace Mono.CSharp {
 					if (iface == t)
 						continue;
 
-					Type[] infered = new Type [CountTypeParameters];
-					if (!TypeManager.MayBecomeEqualGenericInstances (iface, t, infered, null))
+					Type[] inferred = new Type [CountTypeParameters];
+					if (!TypeManager.MayBecomeEqualGenericInstances (iface, t, inferred, null))
 						continue;
 
 					Report.Error (695, Location,
diff --git a/mcs/mcs/delegate.cs b/mcs/mcs/delegate.cs
index 3342c128625..0a682b01d9c 100644
--- a/mcs/mcs/delegate.cs
+++ b/mcs/mcs/delegate.cs
@@ -653,7 +653,7 @@ namespace Mono.CSharp {
 			if (!mg.HasTypeArguments &&
 			    !TypeManager.InferTypeArguments (param, ref found_method)) {
 				Report.Error (411, loc, "The type arguments for " +
-					      "method `{0}' cannot be infered from " +
+					      "method `{0}' cannot be inferred from " +
 					      "the usage. Try specifying the type " +
 					      "arguments explicitly.", method_desc);
 				return;
diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 5d95df1442a..39b3de6869f 100644
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -4658,7 +4658,7 @@ namespace Mono.CSharp {
 
 						Report.Error (
 							411, loc, "The type arguments for " +
-							"method `{0}' cannot be infered from " +
+							"method `{0}' cannot be inferred from " +
 							"the usage. Try specifying the type " +
 							"arguments explicitly.", report_name);
 						return null;