private void PrivateFieldNameMustStartWithUnderscoreFollowedByLowerCase(Field field)
{
if (field.Generated)
{
return;
}
if (field.Const)
{
return;
}
if (IsReadonlyStatic(field))
{
return;
}
if (ViolatesFieldNameRule(field.Declaration.Name))
{
AddViolation(
field,
"PrivateFieldNameMustStartWithUnderscoreFollowedByLowerCase",
new object[0]);
}
}
private void CheckFieldPrefix(Field field, Dictionary<string, string> validPrefixes)
{
int index = MovePastPrefix(field.Declaration.Name);
if (char.IsLower(field.Declaration.Name, index))
{
this.CheckHungarian(field.Declaration.Name, index, field.LineNumber, field, validPrefixes);
if (field.Const)
{
base.AddViolation(field, field.LineNumber, Microsoft.StyleCop.CSharp.Rules.ConstFieldNamesMustBeginWithUpperCaseLetter, new object[] { field.Declaration.Name });
}
else if (((field.AccessModifier == AccessModifierType.Public) || (field.AccessModifier == AccessModifierType.Internal)) || (field.AccessModifier == AccessModifierType.ProtectedInternal))
{
base.AddViolation(field, field.LineNumber, Microsoft.StyleCop.CSharp.Rules.AccessibleFieldsMustBeginWithUpperCaseLetter, new object[] { field.Declaration.Name });
}
if (field.Readonly && (field.Declaration.AccessModifierType != AccessModifierType.Private))
{
base.AddViolation(field, field.LineNumber, Microsoft.StyleCop.CSharp.Rules.NonPrivateReadonlyFieldsMustBeginWithUpperCaseLetter, new object[] { field.Declaration.Name });
}
}
else if (((!field.Const && !field.Readonly) && ((field.AccessModifier != AccessModifierType.Public) && (field.AccessModifier != AccessModifierType.Internal))) && (field.AccessModifier != AccessModifierType.ProtectedInternal))
{
base.AddViolation(field, field.LineNumber, Microsoft.StyleCop.CSharp.Rules.FieldNamesMustBeginWithLowerCaseLetter, new object[] { field.Declaration.Name });
}
}
/// <summary>
/// Parses and returns a field.
/// </summary>
/// <param name="parent">The parent of the element.</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>
/// <param name="xmlHeader">The element's documentation header.</param>
/// <param name="attributes">The attributes on the element.</param>
/// <returns>Returns the element.</returns>
private Field ParseField(
CsElement parent,
Reference<ICodePart> elementReference,
bool unsafeCode,
bool generated,
XmlHeader xmlHeader,
ICollection<Attribute> attributes)
{
Param.AssertNotNull(parent, "parent");
Param.AssertNotNull(elementReference, "elementReference");
Param.Ignore(unsafeCode);
Param.Ignore(generated);
Param.Ignore(xmlHeader);
Param.Ignore(attributes);
Node<CsToken> previousTokenNode = this.tokens.Last;
// Get the modifiers and access.
AccessModifierType accessModifier = AccessModifierType.Private;
Dictionary<CsTokenType, CsToken> modifiers = this.GetElementModifiers(elementReference, ref accessModifier, FieldModifiers);
unsafeCode |= modifiers.ContainsKey(CsTokenType.Unsafe);
// Get the field type.
TypeToken fieldType = this.GetTypeToken(elementReference, unsafeCode, true);
Node<CsToken> fieldTypeNode = this.tokens.InsertLast(fieldType);
// Get all of the variable declarators.
IList<VariableDeclaratorExpression> declarators = this.ParseFieldDeclarators(elementReference, unsafeCode, fieldType);
if (declarators.Count == 0)
{
throw this.CreateSyntaxException();
}
VariableDeclarationExpression declarationExpression = new VariableDeclarationExpression(
new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last),
new LiteralExpression(this.tokens, fieldTypeNode),
declarators);
// Create the field.
Node<CsToken> firstTokenNode = previousTokenNode == null ? this.tokens.First : previousTokenNode.Next;
CsTokenList declarationTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last);
Declaration declaration = new Declaration(
declarationTokens, declarators[0].Identifier.Text, ElementType.Field, accessModifier, modifiers);
Field field = new Field(
this.document, parent, xmlHeader, attributes, declaration, fieldType, unsafeCode, generated);
elementReference.Target = field;
// Get the trailing semicolon.
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon, elementReference));
// Create the variable declaration statement and add it to the field.
field.VariableDeclarationStatement = new VariableDeclarationStatement(
new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last),
field.Const,
declarationExpression);
return field;
}
private Field ParseField(CsElement parent, bool unsafeCode, bool generated, XmlHeader xmlHeader, ICollection<Microsoft.StyleCop.CSharp.Attribute> attributes)
{
Microsoft.StyleCop.Node<CsToken> last = this.tokens.Last;
AccessModifierType @private = AccessModifierType.Private;
Dictionary<CsTokenType, CsToken> elementModifiers = this.GetElementModifiers(ref @private, FieldModifiers);
unsafeCode |= elementModifiers.ContainsKey(CsTokenType.Unsafe);
TypeToken typeToken = this.GetTypeToken(unsafeCode, true);
Microsoft.StyleCop.Node<CsToken> tokenNode = this.tokens.InsertLast(typeToken);
IList<VariableDeclaratorExpression> declarators = this.ParseFieldDeclarators(unsafeCode, typeToken);
if (declarators.Count == 0)
{
throw this.CreateSyntaxException();
}
VariableDeclarationExpression expression = new VariableDeclarationExpression(new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last), new LiteralExpression(this.tokens, tokenNode), declarators);
Microsoft.StyleCop.Node<CsToken> firstItemNode = (last == null) ? this.tokens.First : last.Next;
CsTokenList tokens = new CsTokenList(this.tokens, firstItemNode, this.tokens.Last);
Declaration declaration = new Declaration(tokens, declarators[0].Identifier.Text, ElementType.Field, @private, elementModifiers);
Field field = new Field(this.document, parent, xmlHeader, attributes, declaration, typeToken, unsafeCode, generated);
this.tokens.Add(this.GetToken(CsTokenType.Semicolon, SymbolType.Semicolon));
field.VariableDeclarationStatement = new VariableDeclarationStatement(new CsTokenList(this.tokens, declarators[0].Tokens.First, this.tokens.Last), field.Const, expression);
return field;
}
/// <summary>
/// Checks a field for compliance with naming prefix rules.
/// </summary>
/// <param name="field">The field element.</param>
/// <param name="validPrefixes">A list of valid prefixes that should not be considered hungarian.</param>
private void CheckFieldPrefix(Field field, Dictionary<string, string> validPrefixes)
{
Param.AssertNotNull(field, "field");
Param.Ignore(validPrefixes);
// Skip past any prefixes in the name.
int index = NamingRules.MovePastPrefix(field.Declaration.Name);
// Check whether the name starts with a lower-case letter.
if (char.IsLower(field.Declaration.Name, index))
{
// Check for hungarian notation.
this.CheckHungarian(field.Declaration.Name, index, field.LineNumber, field, validPrefixes);
// Check casing on the field.
if (field.Const)
{
// Const fields must start with an upper-case letter.
this.AddViolation(
field,
field.LineNumber,
Rules.ConstFieldNamesMustBeginWithUpperCaseLetter,
field.Declaration.Name);
}
else if (field.AccessModifier == AccessModifierType.Public ||
field.AccessModifier == AccessModifierType.Internal ||
field.AccessModifier == AccessModifierType.ProtectedInternal)
{
// Public or internal fields must start with an upper-case letter.
this.AddViolation(
field,
field.LineNumber,
Rules.AccessibleFieldsMustBeginWithUpperCaseLetter,
field.Declaration.Name);
}
// Readonly fields which are not declared private must start with an upper-case letter.
if (field.Readonly && field.Declaration.AccessModifierType != AccessModifierType.Private)
{
this.AddViolation(
field,
field.LineNumber,
Rules.NonPrivateReadonlyFieldsMustBeginWithUpperCaseLetter,
field.Declaration.Name);
}
}
else
{
// Constants must always start with an upper-case letter,
// while readonly fields may start with either an upper-case or
// a lower-case letter. Public or internal fields
// also must always start with an upper-case letter.
if (!field.Const &&
!field.Readonly &&
field.AccessModifier != AccessModifierType.Public &&
field.AccessModifier != AccessModifierType.Internal &&
field.AccessModifier != AccessModifierType.ProtectedInternal)
{
this.AddViolation(
field,
field.LineNumber,
Rules.FieldNamesMustBeginWithLowerCaseLetter,
field.Declaration.Name);
}
}
}
private void VisitField(Field field)
{
PrivateFieldNameMustStartWithUnderscoreFollowedByLowerCase(field);
}
private static bool IsReadonlyStatic(Field field)
{
return field.Readonly && field.Declaration.ContainsModifier(new[] { CsTokenType.Static });
}