/// <summary>
/// Determines whether the token list contains the given strings, skipping whitespace tokens and
/// comments.
/// </summary>
/// <param name="comparisonType">
/// The string comparison type to use.
/// </param>
/// <param name="values">
/// The collection of strings to match against.
/// </param>
/// <returns>
/// Returns true if the tokens match the collection of strings.
/// </returns>
public bool MatchTokens(StringComparison comparisonType, params string[] values)
{
Param.RequireNotNull(values, "values");
Param.Ignore(comparisonType);
return(CsTokenList.MatchTokens(comparisonType, this.First, values));
}
/// <summary>
/// Determines whether the given token list contains the given strings, skipping whitespace tokens and
/// comments.
/// </summary>
/// <param name="start">
/// Begins matching the given strings with this token.
/// </param>
/// <param name="values">
/// The collection of strings to match against.
/// </param>
/// <returns>
/// Returns true if the tokens match the collection of strings.
/// </returns>
public static bool MatchTokens(Node <CsToken> start, params string[] values)
{
Param.RequireNotNull(start, "start");
Param.RequireNotNull(values, "values");
return(CsTokenList.MatchTokens(StringComparison.Ordinal, start, values));
}
/// <summary>
/// Checks a type to determine whether it should use one of the built-in types.
/// </summary>
/// <param name="type">
/// The type to check.
/// </param>
/// <param name="document">
/// The parent document.
/// </param>
private void CheckBuiltInType(Node <CsToken> type, CsDocument document)
{
Param.AssertNotNull(type, "type");
Param.AssertNotNull(document, "document");
Debug.Assert(type.Value is TypeToken, "The type must be a TypeToken");
TypeToken typeToken = (TypeToken)type.Value;
if (type.Value.CsTokenClass != CsTokenClass.GenericType)
{
for (int i = 0; i < this.builtInTypes.Length; ++i)
{
string[] builtInType = this.builtInTypes[i];
if (CsTokenList.MatchTokens(typeToken.ChildTokens.First, builtInType[0]) ||
CsTokenList.MatchTokens(typeToken.ChildTokens.First, "System", ".", builtInType[0]))
{
// If the previous token is an equals sign, then this is a using alias directive. For example:
// using SomeAlias = System.String;
// If the previous token is the 'static' keyword, then this is a using static directive. For example:
// using static System.String;
bool shouldBuiltInTypeAliasBeUsed = true;
for (Node <CsToken> previous = type.Previous; previous != null; previous = previous.Previous)
{
if (previous.Value.CsTokenType != CsTokenType.EndOfLine && previous.Value.CsTokenType != CsTokenType.MultiLineComment &&
previous.Value.CsTokenType != CsTokenType.SingleLineComment && previous.Value.CsTokenType != CsTokenType.WhiteSpace)
{
if (previous.Value.Text == "=" || previous.Value.Text == "static")
{
shouldBuiltInTypeAliasBeUsed = false;
}
break;
}
}
if (shouldBuiltInTypeAliasBeUsed)
{
this.AddViolation(
typeToken.FindParentElement(), typeToken.LineNumber, Rules.UseBuiltInTypeAlias, builtInType[2], builtInType[0], builtInType[1]);
}
break;
}
}
}
for (Node <CsToken> childToken = typeToken.ChildTokens.First; childToken != null; childToken = childToken.Next)
{
if (childToken.Value.CsTokenClass == CsTokenClass.Type || childToken.Value.CsTokenClass == CsTokenClass.GenericType)
{
this.CheckBuiltInType(childToken, document);
}
}
}
/// <summary>
/// Returns true if the node Contains any sort of <see cref="Nullable"/>.
/// </summary>
/// <param name="token">
/// The token to check.
/// </param>
/// <returns>
/// True if <see cref="Nullable"/> otherwise False.
/// </returns>
public static bool TokenContainNullable(Node <CsToken> token)
{
if (CsTokenList.MatchTokens(StringComparison.Ordinal, token, new[] { "System", ".", "Nullable" }) ||
CsTokenList.MatchTokens(StringComparison.Ordinal, token, new[] { "global", "::", "System", ".", "Nullable" }) ||
token.Value.Text.Equals("Nullable", StringComparison.Ordinal))
{
return(true);
}
return(false);
}
/// <summary>
/// Checks a type to determine whether it should use one of the built-in types.
/// </summary>
/// <param name="type">
/// The type to check.
/// </param>
private void CheckBuiltInTypeForMemberAccessExpressions(Node <CsToken> type)
{
Param.AssertNotNull(type, "type");
for (int i = 0; i < this.builtInTypes.Length; ++i)
{
string[] builtInType = this.builtInTypes[i];
if (CsTokenList.MatchTokens(type, builtInType[0]) || CsTokenList.MatchTokens(type, "System", ".", builtInType[0]))
{
this.AddViolation(type.Value.FindParentElement(), type.Value.LineNumber, Rules.UseBuiltInTypeAlias, builtInType[2], builtInType[0], builtInType[1]);
break;
}
}
}
/// <summary>
/// Determines whether the token list contains the given strings, skipping whitespace tokens and
/// comments.
/// </summary>
/// <param name="values">
/// The collection of strings to match against.
/// </param>
/// <returns>
/// Returns true if the tokens match the collection of strings.
/// </returns>
public bool MatchTokens(params string[] values)
{
Param.RequireNotNull(values, "values");
return(CsTokenList.MatchTokens(this.First, values));
}