Purge more Invariant culture usages

src/NHibernate/Dialect/Function/AnsiTrimEmulationFunction.cs

@@ -98,8 +98,8 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 				//      so we trim leading and trailing spaces
 				return BothSpaceTrim.Render(args, factory);
 			}
-			
-			if (StringHelper.EqualsCaseInsensitive("from", firstArg))
+
+			if ("from".Equals(firstArg, StringComparison.OrdinalIgnoreCase))
 			{
 				// we have the form: trim(from trimSource).
 				//      This is functionally equivalent to trim(trimSource)
@@ -118,15 +118,15 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 			// trim-specification has been specified.  we handle the
 			// exception to that explicitly
 			int potentialTrimCharacterArgIndex = 1;
-			if (StringHelper.EqualsCaseInsensitive("leading", firstArg))
+			if ("leading".Equals(firstArg, StringComparison.OrdinalIgnoreCase))
 			{
 				trailing = false;
 			}
-			else if (StringHelper.EqualsCaseInsensitive("trailing", firstArg))
+			else if ("trailing".Equals(firstArg, StringComparison.OrdinalIgnoreCase))
 			{
 				leading = false;
 			}
-			else if (StringHelper.EqualsCaseInsensitive("both", firstArg))
+			else if ("both".Equals(firstArg, StringComparison.OrdinalIgnoreCase))
 			{
 			}
 			else
@@ -135,7 +135,7 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 			}
 
 			object potentialTrimCharacter = args[potentialTrimCharacterArgIndex];
-			if (StringHelper.EqualsCaseInsensitive("from", potentialTrimCharacter.ToString()))
+			if ("from".Equals(potentialTrimCharacter.ToString(), StringComparison.OrdinalIgnoreCase))
 			{
 				trimCharacter = "' '";
 				trimSource = args[potentialTrimCharacterArgIndex + 1];
@@ -148,7 +148,7 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 			else
 			{
 				trimCharacter = potentialTrimCharacter;
-				if (StringHelper.EqualsCaseInsensitive("from", args[potentialTrimCharacterArgIndex + 1].ToString()))
+				if ("from".Equals(args[potentialTrimCharacterArgIndex + 1].ToString(), StringComparison.OrdinalIgnoreCase))
 				{
 					trimSource = args[potentialTrimCharacterArgIndex + 2];
 				}

src/NHibernate/Dialect/Function/CastFunction.cs

@@ -92,7 +92,7 @@ protected virtual bool CastingIsRequired(string sqlType)
 
 		bool IFunctionGrammar.IsSeparator(string token)
 		{
-			return "as".Equals(token, StringComparison.InvariantCultureIgnoreCase);
+			return "as".Equals(token, StringComparison.OrdinalIgnoreCase);
 		}
 
 		bool IFunctionGrammar.IsKnownArgument(string token)

src/NHibernate/Dialect/Function/ClassicAggregateFunction.cs

@@ -77,8 +77,8 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 			if (args.Count > 1)
 			{
 				object firstArg = args[0];
-				if (!StringHelper.EqualsCaseInsensitive("distinct", firstArg.ToString()) &&
-				    !StringHelper.EqualsCaseInsensitive("all", firstArg.ToString()))
+				if (!"distinct".Equals(firstArg.ToString(), StringComparison.OrdinalIgnoreCase) &&
+				    !"all".Equals(firstArg.ToString(), StringComparison.OrdinalIgnoreCase))
 				{
 					throw new QueryException(string.Format("Aggregate {0}(): token unknow {1}.", name, firstArg));
 				}

src/NHibernate/Driver/NDataReader.cs

@@ -612,7 +612,7 @@ public int GetOrdinal(string colName)
 
 				foreach (KeyValuePair<string, int> pair in fieldNameToIndex)
 				{
-					if (StringHelper.EqualsCaseInsensitive(pair.Key, colName))
+					if (string.Equals(pair.Key, colName, StringComparison.InvariantCultureIgnoreCase))
 					{
 						return pair.Value;
 					}

src/NHibernate/Hql/QuerySplitter.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Text;
 using NHibernate.Engine;
@@ -60,7 +59,6 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor
 			string next = null;
 
 			templateQuery.Append(tokens[0]);
-			bool isSelectClause = StringHelper.EqualsCaseInsensitive("select", tokens[0]);
 
 			for (int i = 1; i < tokens.Length; i++)
 			{
@@ -70,9 +68,6 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor
 					last = tokens[i - 1].ToLowerInvariant();
 				}
 
-				// select-range is terminated by declaration of "from"
-				isSelectClause = !StringHelper.EqualsCaseInsensitive("from", tokens[i]);
-
 				string token = tokens[i];
 				if (!ParserHelper.IsWhitespace(token) || last == null)
 				{
@@ -120,11 +115,5 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor
 			}
 			return results;
 		}
-
-		private static bool IsPossiblyClassName(string last, string next)
-		{
-			return ParserHelper.EntityClass.Equals(last) ||
-				   (beforeClassTokens.Contains(last) && !notAfterClassTokens.Contains(next));
-		}
 	}
 }

src/NHibernate/Mapping/Column.cs

@@ -155,7 +155,7 @@ private string GetAlias(int maxAliasLength)
 			//    But I will leave it like this for now to make it look similar. /Oskar 2016-08-20
 			bool useRawName = name.Length + suffix.Length <= usableLength &&
 			                  !_quoted &&
-			                  !StringHelper.EqualsCaseInsensitive(name, "rowid");
+			                  !"rowid".Equals(name, StringComparison.OrdinalIgnoreCase);
 			if (!useRawName)
 			{
 				if (suffix.Length >= usableLength)

src/NHibernate/Mapping/ManyToOne.cs

@@ -73,7 +73,7 @@ public void CreatePropertyRefConstraints(IDictionary<string, PersistentClass> pe
 				if (property == null)
 					throw new MappingException("Could not find property " + ReferencedPropertyName + " on " + ReferencedEntityName);
 
-				if (!HasFormula && !"none".Equals(ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))
+				if (!HasFormula && !"none".Equals(ForeignKeyName, StringComparison.OrdinalIgnoreCase))
 				{
 
 					IEnumerable<Column> ce = new SafetyEnumerable<Column>(property.ColumnIterator);

src/NHibernate/Mapping/ReferenceDependantValue.cs

@@ -24,7 +24,7 @@ public IEnumerable<Column> ReferenceColumns
 
 		public override void CreateForeignKeyOfEntity(string entityName)
 		{
-			if (!HasFormula && !string.Equals("none", ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))
+			if (!HasFormula && !string.Equals("none", ForeignKeyName, StringComparison.OrdinalIgnoreCase))
 			{
 				var referencedColumns = new List<Column>(_prototype.ColumnSpan);
 				foreach (Column column in _prototype.ColumnIterator)

src/NHibernate/Mapping/SimpleValue.cs

@@ -75,7 +75,7 @@ public virtual bool IsComposite
 
 		public virtual void CreateForeignKeyOfEntity(string entityName)
 		{
-			if (!HasFormula && ! "none".Equals(ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))
+			if (!HasFormula && ! "none".Equals(ForeignKeyName, StringComparison.OrdinalIgnoreCase))
 			{
 				ForeignKey fk = table.CreateForeignKey(ForeignKeyName, ConstraintColumns, entityName);
 				fk.CascadeDeleteEnabled = cascadeDeleteEnabled;

src/NHibernate/SqlCommand/Parser/MsSqlSelectParser.cs

@@ -131,15 +131,15 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke
 					case SqlTokenType.Text:
 						if (blockLevel != 0) break;
 
-						if (token.Equals(",", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals(",", StringComparison.Ordinal))
 						{
 							if (columnAliasToken != null)
 							{
 								yield return ParseSelectColumnDefinition(columnBeginToken, columnEndToken ?? columnAliasToken, columnAliasToken);
 							}
 						}
 
-						if (token.Equals("from", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals("from", StringComparison.OrdinalIgnoreCase))
 						{
 							if (columnAliasToken != null)
 							{
@@ -148,7 +148,7 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke
 							yield break;
 						}
 
-						if (token.Equals("as", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals("as", StringComparison.OrdinalIgnoreCase))
 						{
 							columnEndToken = prevToken;
 						}
@@ -237,8 +237,8 @@ private IEnumerable<OrderDefinition> ParseOrderDefinitions(IEnumerator<SqlToken>
 					case SqlTokenType.Text:
 						if (blockLevel != 0) break;
 
-						if (token.Equals("asc", StringComparison.InvariantCultureIgnoreCase)
-							|| token.Equals("desc", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals("asc", StringComparison.OrdinalIgnoreCase)
+							|| token.Equals("desc", StringComparison.OrdinalIgnoreCase))
 						{
 							orderEndToken = prevToken;
 							directionToken = token;
@@ -269,7 +269,7 @@ private IEnumerable<OrderDefinition> ParseOrderDefinitions(IEnumerator<SqlToken>
 		private OrderDefinition ParseOrderDefinition(SqlToken beginToken, SqlToken endToken, SqlToken directionToken)
 		{
 			var isDescending = directionToken != null &&
-							   directionToken.Equals("desc", StringComparison.InvariantCultureIgnoreCase);
+							   directionToken.Equals("desc", StringComparison.OrdinalIgnoreCase);
 
 			var columnNameOrIndex = beginToken == endToken
 				? beginToken.Value

src/NHibernate/SqlCommand/Parser/SqlTokenizerExtensions.cs

@@ -23,7 +23,7 @@ public static bool TryParseUntil(this IEnumerator<SqlToken> tokenEnum, string ke
 							nestLevel--;
 							break;
 						case SqlTokenType.Text:
-							if (nestLevel == 0 && token.Equals(keyword, StringComparison.InvariantCultureIgnoreCase)) return true;
+							if (nestLevel == 0 && token.Equals(keyword, StringComparison.OrdinalIgnoreCase)) return true;
 							break;
 					}
 				}
@@ -34,9 +34,7 @@ public static bool TryParseUntil(this IEnumerator<SqlToken> tokenEnum, string ke
 
 		public static bool TryParseUntilFirstMsSqlSelectColumn(this IEnumerator<SqlToken> tokenEnum)
 		{
-			SqlToken selectToken;
-			bool isDistinct;
-			return TryParseUntilFirstMsSqlSelectColumn(tokenEnum, out selectToken, out isDistinct);
+			return TryParseUntilFirstMsSqlSelectColumn(tokenEnum, out _, out _);
 		}
 
 		public static bool TryParseUntilFirstMsSqlSelectColumn(this IEnumerator<SqlToken> tokenEnum, out SqlToken selectToken, out bool isDistinct)
@@ -100,9 +98,7 @@ public static bool TryParseUntilFirstOrderColumn(this IEnumerator<SqlToken> toke
 				orderToken = tokenEnum.Current;
 				if (tokenEnum.MoveNext())
 				{
-					return tokenEnum.Current.Equals("by", StringComparison.InvariantCultureIgnoreCase)
-						? tokenEnum.MoveNext()
-						: false;
+					return tokenEnum.Current.Equals("by", StringComparison.OrdinalIgnoreCase) && tokenEnum.MoveNext();
 				}
 			}
 

src/NHibernate/SqlCommand/SqlString.cs

@@ -374,7 +374,7 @@ public bool EndsWithCaseInsensitive(string value)
 		{
 			return value != null
 				&& value.Length <= _length
-				&& IndexOf(value, _length - value.Length, value.Length, StringComparison.CurrentCultureIgnoreCase) >= 0;
+				&& IndexOf(value, _length - value.Length, value.Length, StringComparison.InvariantCultureIgnoreCase) >= 0;
 		}
 
 		public IEnumerable<Parameter> GetParameters()

src/NHibernate/SqlCommand/SubselectClauseExtractor.cs

@@ -111,7 +111,7 @@ public static bool HasOrderBy(SqlString subselect)
 		private int FindFromClauseInPart(string part)
 		{
 			int afterLastClosingParenIndex = 0;
-			int fromIndex = StringHelper.IndexOfCaseInsensitive(part, FromClauseToken);
+			int fromIndex = part.IndexOf(FromClauseToken, StringComparison.OrdinalIgnoreCase);
 
 			for (int i = 0; i < part.Length; i++)
 			{
@@ -133,13 +133,13 @@ private int FindFromClauseInPart(string part)
 					}
 
 					afterLastClosingParenIndex = i + 1;
-					fromIndex = StringHelper.IndexOfCaseInsensitive(part, FromClauseToken, afterLastClosingParenIndex);
+					fromIndex = part.IndexOf(FromClauseToken, afterLastClosingParenIndex, StringComparison.OrdinalIgnoreCase);
 				}
 			}
 
 			if (afterLastClosingParenIndex == 0)
 			{
-				fromIndex = StringHelper.IndexOfCaseInsensitive(part, FromClauseToken);
+				fromIndex = part.IndexOf(FromClauseToken, StringComparison.OrdinalIgnoreCase);
 			}
 
 			if(parenNestCount > 0)
@@ -163,7 +163,7 @@ private void CheckLastPartForOrderByClause()
 			}
 
 			string partString = part as string;
-			int index = StringHelper.LastIndexOfCaseInsensitive(partString, OrderByToken);
+			int index = partString.LastIndexOf(OrderByToken, StringComparison.OrdinalIgnoreCase);
 			if (index >= 0)
 			{
 				lastOrderByPartIndex = builder.Count - 1;
@@ -175,8 +175,7 @@ private void CheckLastPartForOrderByClause()
 
 		private void IgnoreOrderByInSubselect(string partString)
 		{
-			int index;
-			index = StringHelper.LastIndexOfCaseInsensitive(partString, ")");
+			var index = partString.LastIndexOf(")", StringComparison.Ordinal);
 			if (index >= 0 && ParenIsAfterLastOrderBy(index))
 			{
 				lastOrderByPartIndex = -1;

src/NHibernate/Type/CharBooleanType.cs

@@ -37,7 +37,7 @@ public override object Get(DbDataReader rs, int index, ISessionImplementor sessi
 			}
 			else
 			{
-				return StringHelper.EqualsCaseInsensitive(code, TrueString);
+				return code.Equals(TrueString, StringComparison.InvariantCultureIgnoreCase);
 			}
 		}
 
@@ -68,11 +68,11 @@ public override string ObjectToSQLString(object value, Dialect.Dialect dialect)
 		/// <returns></returns>
 		public override object StringToObject(String xml)
 		{
-			if (StringHelper.EqualsCaseInsensitive(TrueString, xml))
+			if (string.Equals(TrueString, xml, StringComparison.InvariantCultureIgnoreCase))
 			{
 				return true;
 			}
-			else if (StringHelper.EqualsCaseInsensitive(FalseString, xml))
+			else if (string.Equals(FalseString, xml, StringComparison.InvariantCultureIgnoreCase))
 			{
 				return false;
 			}
@@ -82,4 +82,4 @@ public override object StringToObject(String xml)
 			}
 		}
 	}
-}
+}

src/NHibernate/Util/StringHelper.cs

@@ -658,31 +658,43 @@ public static string Unroot(string qualifiedName)
 			return (loc < 0) ? qualifiedName : qualifiedName.Substring(loc + 1);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static bool EqualsCaseInsensitive(string a, string b)
 		{
 			return StringComparer.InvariantCultureIgnoreCase.Compare(a, b) == 0;
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static int IndexOfCaseInsensitive(string source, string value)
 		{
 			return source.IndexOf(value, StringComparison.InvariantCultureIgnoreCase);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static int IndexOfCaseInsensitive(string source, string value, int startIndex)
 		{
 			return source.IndexOf(value, startIndex, StringComparison.InvariantCultureIgnoreCase);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static int IndexOfCaseInsensitive(string source, string value, int startIndex, int count)
 		{
 			return source.IndexOf(value, startIndex, count, StringComparison.InvariantCultureIgnoreCase);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static int LastIndexOfCaseInsensitive(string source, string value)
 		{
 			return source.LastIndexOf(value, StringComparison.InvariantCultureIgnoreCase);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static bool StartsWithCaseInsensitive(string source, string prefix)
 		{
 			return source.StartsWith(prefix, StringComparison.InvariantCultureIgnoreCase);