/// <summary>
/// Compares the order of two using directives.
/// </summary>
/// <param name="firstUsing">The first using directive.</param>
/// <param name="secondUsing">The second using directive.</param>
/// <returns>Returns false if the elements are out of order.</returns>
private bool CompareOrderOfUsingDirectives(UsingDirective firstUsing, UsingDirective secondUsing)
{
Param.AssertNotNull(firstUsing, "firstUsing");
Param.AssertNotNull(secondUsing, "secondUsing");
if (string.IsNullOrEmpty(firstUsing.Alias))
{
if (string.IsNullOrEmpty(secondUsing.Alias))
{
bool isFirstSystem = firstUsing.NamespaceType.StartsWith("System", StringComparison.Ordinal) || firstUsing.NamespaceType.StartsWith("System.", StringComparison.Ordinal);
bool isSecondSystem = secondUsing.NamespaceType.Equals("System", StringComparison.Ordinal) || secondUsing.NamespaceType.StartsWith("System.", StringComparison.Ordinal);
// Neither of the usings is an alias. First, ensure that System namespaces are placed above all
// non-System namespaces.
if (isSecondSystem && !isFirstSystem)
{
this.AddViolation(secondUsing, Rules.SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives);
return false;
}
else if ((isFirstSystem && isSecondSystem) || (!isFirstSystem && !isSecondSystem))
{
if (!CheckNamespaceOrdering(firstUsing.NamespaceType, secondUsing.NamespaceType))
{
// The usings are not in alphabetical order by namespace.
this.AddViolation(firstUsing, Rules.UsingDirectivesMustBeOrderedAlphabeticallyByNamespace);
return false;
}
}
}
}
else
{
if (string.IsNullOrEmpty(secondUsing.Alias))
{
// The first using is an alias, but the second is not. They are in the wrong order.
this.AddViolation(firstUsing, Rules.UsingAliasDirectivesMustBePlacedAfterOtherUsingDirectives);
return false;
}
else
{
// Both of the usings are aliases. Verify that they are sorted alphabetically by the alias name.
if (string.Compare(firstUsing.Alias, secondUsing.Alias, StringComparison.OrdinalIgnoreCase) > 0)
{
// The usings are not sorted alphabetically by the alias.
this.AddViolation(firstUsing, Rules.UsingAliasDirectivesMustBeOrderedAlphabeticallyByAliasName);
return false;
}
}
}
return true;
}
/// <summary>
/// Parses and returns a using directive.
/// </summary>
/// <param name="parent">The parent of the namespace.</param>
/// <param name="elementReference">A reference to the element being created.</param>
/// <param name="unsafeCode">Indicates whether the code is marked as unsafe.</param>
/// <param name="generated">Indicates whether the code is marked as generated code.</param>
/// <returns>Returns the element.</returns>
private UsingDirective ParseUsingDirective(CsElement parent, Reference<ICodePart> elementReference, bool unsafeCode, bool generated)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
// Add the using token.
Node<CsToken> firstToken = this.tokens.InsertLast(this.GetToken(CsTokenType.Using, SymbolType.Using, elementReference));
// The next symbol will either be the namespace, or an alias. To determine this, look past this to see if there is an equals sign.
Symbol peekAhead = this.GetNextSymbol(SymbolType.Other, elementReference);
int index = this.GetNextCodeSymbolIndex(2);
if (index == -1)
{
throw this.CreateSyntaxException();
}
CsToken alias = null;
peekAhead = this.symbols.Peek(index);
if (peekAhead.SymbolType == SymbolType.Equals)
{
// There is an alias. First collect the alias.
alias = this.GetToken(CsTokenType.Other, SymbolType.Other, elementReference);
this.tokens.Add(alias);
// Next collect the equals sign.
this.tokens.Add(this.GetOperatorToken(OperatorType.Equals, elementReference));
}
// Collect and add the namespace token.
TypeToken @namespace = this.GetTypeToken(elementReference, unsafeCode, false);
this.tokens.Add(@namespace);
// Create the declaration.
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstToken, this.tokens.Last);
Declaration declaration = new Declaration(
declarationTokens,
alias == null ? @namespace.Text : alias.Text,
ElementType.UsingDirective,
AccessModifierType.Public);
// Get the closing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference));
// Create the using directive.
var element = new UsingDirective(this.document, parent, declaration, generated, @namespace.Text, alias == null ? null : alias.Text);
elementReference.Target = element;
return element;
}
private bool CompareOrderOfUsingDirectives(UsingDirective firstUsing, UsingDirective secondUsing)
{
if (string.IsNullOrEmpty(firstUsing.Alias))
{
if (string.IsNullOrEmpty(secondUsing.Alias))
{
bool flag = firstUsing.NamespaceType.StartsWith("System", StringComparison.Ordinal) || firstUsing.NamespaceType.StartsWith("System.", StringComparison.Ordinal);
bool flag2 = secondUsing.NamespaceType.Equals("System", StringComparison.Ordinal) || secondUsing.NamespaceType.StartsWith("System.", StringComparison.Ordinal);
if (flag2 && !flag)
{
base.AddViolation(secondUsing, Microsoft.StyleCop.CSharp.Rules.SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives, new object[0]);
return false;
}
if (((flag && flag2) || (!flag && !flag2)) && (string.Compare(firstUsing.NamespaceType, secondUsing.NamespaceType, StringComparison.InvariantCultureIgnoreCase) > 0))
{
base.AddViolation(firstUsing, Microsoft.StyleCop.CSharp.Rules.UsingDirectivesMustBeOrderedAlphabeticallyByNamespace, new object[0]);
return false;
}
}
}
else
{
if (string.IsNullOrEmpty(secondUsing.Alias))
{
base.AddViolation(firstUsing, Microsoft.StyleCop.CSharp.Rules.UsingAliasDirectivesMustBePlacedAfterOtherUsingDirectives, new object[0]);
return false;
}
if (string.Compare(firstUsing.Alias, secondUsing.Alias, StringComparison.InvariantCultureIgnoreCase) > 0)
{
base.AddViolation(firstUsing, Microsoft.StyleCop.CSharp.Rules.UsingAliasDirectivesMustBeOrderedAlphabeticallyByAliasName, new object[0]);
return false;
}
}
return true;
}