/// <summary>
/// Checks the methods within the given document.
/// </summary>
/// <param name="document">The document to check.</param>
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
/*
// Get the autoupdate setting.
string flag = null;
if (document.File.Project.LocalSettings != null)
{
flag = document.File.Project.LocalSettings.GetProperty("ParamCheckAutomatic");
if (flag == null && document.File.Project.GlobalSettings != null)
{
flag = document.File.Project.GlobalSettings.GetProperty("ParamCheckAutomatic");
}
}
this.autoUpdate = (flag != null && flag == "1");
*/
// Analyze the document.
CsDocument csdocument = (CsDocument)document;
if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
{
this.ProcessElement(csdocument, csdocument.RootElement);
}
}
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument document2 = (CsDocument) document;
if ((document2.RootElement != null) && !document2.RootElement.Generated)
{
TopLevelElements context = new TopLevelElements();
document2.WalkDocument<TopLevelElements>(new CodeWalkerElementVisitor<TopLevelElements>(this.ProcessElement), new CodeWalkerStatementVisitor<TopLevelElements>(this.ProcessStatement), new CodeWalkerExpressionVisitor<TopLevelElements>(this.ProcessExpression), context);
if (context.Classes.Count > 1)
{
string fullNamespaceName = string.Empty;
foreach (Class class2 in context.Classes)
{
if (!class2.Declaration.ContainsModifier(new CsTokenType[] { CsTokenType.Partial }) || (!string.IsNullOrEmpty(fullNamespaceName) && (string.Compare(fullNamespaceName, class2.FullNamespaceName, StringComparison.Ordinal) != 0)))
{
base.AddViolation(class2, 1, Microsoft.StyleCop.CSharp.Rules.FileMayOnlyContainASingleClass, new object[0]);
break;
}
fullNamespaceName = class2.FullNamespaceName;
}
}
if (context.Namespaces.Count > 1)
{
base.AddViolation(document2.RootElement, Microsoft.StyleCop.CSharp.Rules.FileMayOnlyContainASingleNamespace, new object[0]);
}
}
}
/// <summary>
/// Checks the methods within the given document.
/// </summary>
/// <param name="document">The document to check.</param>
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument csdocument = (CsDocument)document;
Settings settings = new Settings();
settings.DoNotUseRegions = this.IsRuleEnabled(document, Rules.DoNotUseRegions.ToString());
settings.DoNotPlaceRegionsWithinElements = this.IsRuleEnabled(document, Rules.DoNotPlaceRegionsWithinElements.ToString());
if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
{
// Checks various formatting rules.
csdocument.WalkDocument(
new CodeWalkerElementVisitor<object>(this.ProcessElement),
null,
new CodeWalkerExpressionVisitor<object>(this.ProcessExpression),
settings);
// Check statement formatting rules.
this.CheckStatementFormattingRulesForElement(csdocument.RootElement);
// Check the class member rules.
this.CheckClassMemberRulesForElements(csdocument.RootElement, null, null);
// Looks for empty comments.
this.CheckForEmptyComments(csdocument.RootElement);
// Checks the usage of the built-in types and empty strings.
this.IterateTokenList(csdocument, settings);
}
}
/// <summary>
/// Checks the order of the elements within the given document.
/// </summary>
/// <param name="document">The document to check.</param>
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument csdocument = (CsDocument)document;
if (csdocument.RootElement != null)
{
// Get the value of the GeneratedCodeElementOrder property.
bool checkGeneratedCode = OrderingRules.GeneratedCodeElementOrderDefaultValueProperty;
if (document.Settings != null)
{
BooleanProperty setting = this.GetSetting(document.Settings, OrderingRules.GeneratedCodeElementOrderProperty) as BooleanProperty;
if (setting != null)
{
checkGeneratedCode = setting.Value;
}
// Check the rest of the elements.
this.ProcessElements(csdocument.RootElement, checkGeneratedCode);
}
this.CheckUsingDirectiveOrder(csdocument.RootElement);
}
}
public override bool ParseFile(SourceCode sourceCode, int passNumber, ref CodeDocument document)
{
Param.RequireNotNull(sourceCode, "sourceCode");
Param.RequireGreaterThanOrEqualToZero(passNumber, "passNumber");
if (passNumber == 0)
{
try
{
using (TextReader reader = sourceCode.Read())
{
if (reader == null)
{
base.AddViolation(sourceCode, 1, Microsoft.StyleCop.CSharp.Rules.FileMustBeReadable, new object[0]);
}
else
{
CodeLexer lexer = new CodeLexer(this, sourceCode, new CodeReader(reader));
CodeParser parser = new CodeParser(this, lexer);
parser.ParseDocument();
document = parser.Document;
}
}
}
catch (SyntaxException exception)
{
base.AddViolation(exception.SourceCode, exception.LineNumber, Microsoft.StyleCop.CSharp.Rules.SyntaxException, new object[] { exception.Message });
CsDocument document2 = new CsDocument(sourceCode, this);
document2.FileHeader = new FileHeader(string.Empty);
document = document2;
}
}
return false;
}
/// <summary>
/// Analyzes source document.
/// </summary>
public void AnalyzeDocument(CodeDocument document)
{
CustomRulesSettings settings = new CustomRulesSettings();
settings.Initialize(m_parent, document);
CsDocument doc = (CsDocument)document;
AnalyzePlainText(doc, settings);
AnalyzeElements(doc.RootElement.ChildElements, settings);
}
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
var csDocument = (CsDocument)document;
if ((csDocument.RootElement != null) && !csDocument.RootElement.Generated)
{
csDocument.WalkDocument(VisitElement);
}
}
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument document2 = (CsDocument) document;
if ((document2.RootElement != null) && !document2.RootElement.Generated)
{
this.CheckSpacing(document2.RootElement, document2.Tokens, false);
}
}
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument document2 = (CsDocument) document;
if ((document2.RootElement != null) && !document2.RootElement.Generated)
{
Dictionary<string, string> prefixes = this.GetPrefixes(document.Settings);
this.ProcessElement(document2.RootElement, prefixes, false);
}
}
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument document2 = (CsDocument) document;
if ((document2.RootElement != null) && !document2.RootElement.Generated)
{
document2.WalkDocument(new CodeWalkerElementVisitor<object>(this.VisitElement), new CodeWalkerStatementVisitor<object>(this.CheckStatementCurlyBracketPlacement), new CodeWalkerExpressionVisitor<object>(this.CheckExpressionCurlyBracketPlacement));
this.CheckLineSpacing(document2);
}
}
/// <summary>
/// Analyzes source document.
/// </summary>
public void AnalyzeDocument(CodeDocument document)
{
CheckOriginalRule(document, Constants.LayoutRulesAnalyzerId, Rules.ElementMustNotBeOnSingleLine);
CheckOriginalRule(document, Constants.LayoutRulesAnalyzerId, Rules.OpeningCurlyBracketsMustNotBePrecededByBlankLine);
CheckOriginalRule(document, Constants.LayoutRulesAnalyzerId, Rules.ClosingCurlyBracketMustBeFollowedByBlankLine);
CheckOriginalRule(document, Constants.LayoutRulesAnalyzerId, Rules.ElementsMustBeSeparatedByBlankLine);
m_customNamingAnalyzer.AnalyzeDocument(document);
m_customLayoutAnalyzer.AnalyzeDocument(document);
m_customDocumentationAnalyzer.AnalyzeDocument(document);
}
/// <summary>
/// Checks whether specified rule is enabled.
/// </summary>
public override bool IsRuleEnabled(CodeDocument document, string ruleName)
{
if (SpecialRunningParameters != null)
{
if (!String.IsNullOrEmpty(SpecialRunningParameters.OnlyEnabledRule))
{
return ruleName == SpecialRunningParameters.OnlyEnabledRule;
}
}
return base.IsRuleEnabled(document, ruleName);
}
/// <summary>
/// Analyzes source document.
/// </summary>
public override void AnalyzeDocument(CodeDocument document)
{
CsDocument doc = (CsDocument)document;
if (doc.RootElement.Generated)
return;
if (IsRuleEnabled(document, Rules.AdvancedNamingRules.ToString()))
m_advancedNamingRules.AnalyzeDocument(document);
m_extendedOriginalRules.AnalyzeDocument(document);
m_moreCustomRules.AnalyzeDocument(document);
}
/// <summary>
/// Checks the placement of brackets within the given document.
/// </summary>
/// <param name="document">The document to check.</param>
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument csdocument = (CsDocument)document;
if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
{
// Check placement of curly brackets.
csdocument.WalkDocument(
new CodeWalkerElementVisitor<object>(this.VisitElement),
new CodeWalkerStatementVisitor<object>(this.CheckStatementCurlyBracketPlacement),
new CodeWalkerExpressionVisitor<object>(this.CheckExpressionCurlyBracketPlacement));
// Check line spacing rules.
this.CheckLineSpacing(csdocument);
}
}
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument document2 = (CsDocument) document;
if (document2.RootElement != null)
{
bool checkGeneratedCode = true;
if (document.Settings != null)
{
BooleanProperty setting = base.GetSetting(document.Settings, "GeneratedCodeElementOrder") as BooleanProperty;
if (setting != null)
{
checkGeneratedCode = setting.Value;
}
this.ProcessElements(document2.RootElement, checkGeneratedCode);
}
this.CheckUsingDirectiveOrder(document2.RootElement);
}
}
/// <summary>
/// Returns a value indicating whether to delay analysis of this document until the next pass.
/// </summary>
/// <param name="document">The document to analyze.</param>
/// <param name="passNumber">The current pass number.</param>
/// <returns>Returns true if analysis should be delayed.</returns>
public override bool DelayAnalysis(CodeDocument document, int passNumber)
{
Param.RequireNotNull(document, "document");
Param.Ignore(passNumber);
bool delay = false;
// We sometimes delay pass zero, but never pass one.
if (passNumber == 0)
{
// Get the root element.
CsDocument csdocument = document as CsDocument;
if (csdocument != null && csdocument.RootElement != null)
{
// If the element has any partial classes, structs, or interfaces, delay. This is due
// to the fact that the class members rules need knowledge about all parts of the class
// in order to find all class members.
delay = this.ContainsPartialMembers(csdocument.RootElement);
}
}
return delay;
}
/// <summary>
/// Clears the analyzer tags for the given document and all of its children.
/// </summary>
/// <param name="document">The document to clear.</param>
/// <remarks>
/// <para>During each analysis run, analyzers can store data within each analyzed document for
/// later use. Analyzers store and retrieve this data using the <see cref="SourceAnalyzer.GetDocumentData"/>
/// and <see cref="SourceAnalyzer.SetDocumentData"/> methods.</para>
/// <para>After all analysis has been completed, this analyzer data should be cleared so that
/// it will not conflict with the next analysis. This method can be called to clear all
/// analyzer data which was stored during the previous analysis.</para>
/// </remarks>
internal static void ClearAnalyzerTags(CodeDocument document)
{
Param.AssertNotNull(document, "document");
if (document != null && document.DocumentContents != null)
{
document.DocumentContents.ClearAnalyzerTags();
}
}
public override bool SkipAnalysisForDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
BooleanProperty setting = base.GetSetting(document.Settings, "AnalyzeDesignerFiles") as BooleanProperty;
bool flag = true;
if (setting != null)
{
flag = setting.Value;
}
if (flag || !document.SourceCode.Name.EndsWith(".Designer.cs", StringComparison.OrdinalIgnoreCase))
{
BooleanProperty property2 = base.GetSetting(document.Settings, "AnalyzeGeneratedFiles") as BooleanProperty;
bool flag2 = false;
if (property2 != null)
{
flag2 = property2.Value;
}
if (flag2 || (!document.SourceCode.Name.EndsWith(".g.cs", StringComparison.OrdinalIgnoreCase) && !document.SourceCode.Name.EndsWith(".generated.cs", StringComparison.OrdinalIgnoreCase)))
{
return false;
}
}
return true;
}
/// <summary>
/// Checks whether specified rule is enabled.
/// </summary>
public override bool IsRuleEnabled(CodeDocument document, string ruleName)
{
return true;
}
/// <summary>
/// Initializes settings from specified document.
/// </summary>
public void Initialize(SourceAnalyzer analyzer, CodeDocument document)
{
m_names.Clear();
m_examples.Clear();
m_regulars.Clear();
m_derivings.Clear();
string abbreviations = SettingsManager.GetValue<string>(
analyzer,
document.Settings,
NamingSettings.Abbreviations);
string words = SettingsManager.GetValue<string>(
analyzer,
document.Settings,
NamingSettings.Words);
foreach (string setting in NamingSettings.GetCommon())
{
string name = SettingsManager.GetFriendlyName(analyzer, setting);
m_names.Add(setting, name);
string value = SettingsManager.GetValue<string>(analyzer, document.Settings, setting);
if (String.IsNullOrEmpty(value))
{
m_examples.Add(setting, null);
m_regulars.Add(setting, null);
}
else
{
string example = NamingMacro.BuildExample(value);
m_examples.Add(setting, example);
Regex regex = NamingMacro.BuildRegex(value, abbreviations, words);
m_regulars.Add(setting, regex);
}
}
string derivings = SettingsManager.GetValue<string>(
analyzer,
document.Settings,
NamingSettings.Derivings);
m_derivings.AddRange(
derivings.Split(
new[] { ' ' },
StringSplitOptions.RemoveEmptyEntries));
}
private bool TestAndRunAnalyzers(CodeDocument document, SourceParser parser, ICollection<SourceAnalyzer> analyzers, int passNumber)
{
if (analyzers == null)
{
return true;
}
bool flag = false;
foreach (SourceAnalyzer analyzer in analyzers)
{
if (analyzer.DelayAnalysis(document, passNumber))
{
flag = true;
break;
}
}
if (!flag)
{
this.RunAnalyzers(document, parser, analyzers);
}
return !flag;
}
public override bool IsRuleEnabled(CodeDocument document, string ruleName)
{
Param.RequireNotNull(document, "document");
Param.RequireValidString(ruleName, "ruleName");
if (this.enabledRules != null)
{
Dictionary<string, Rule> dictionary = null;
if (this.enabledRules.TryGetValue(document.SourceCode.Project, out dictionary))
{
return dictionary.ContainsKey(ruleName);
}
}
return base.IsRuleEnabled(document, ruleName);
}
private void RunAnalyzers(CodeDocument document, SourceParser parser, ICollection<SourceAnalyzer> analyzers)
{
if (analyzers != null)
{
if (parser.SkipAnalysisForDocument(document))
{
this.data.Core.SignalOutput(MessageImportance.Normal, string.Format(CultureInfo.CurrentCulture, "Skipping {0}...", new object[] { document.SourceCode.Name }));
}
else
{
foreach (SourceAnalyzer analyzer in analyzers)
{
if (this.data.Core.Cancel)
{
return;
}
SourceParser.ClearAnalyzerTags(document);
try
{
analyzer.AnalyzeDocument(document);
continue;
}
catch (Exception)
{
string output = string.Format(CultureInfo.CurrentCulture, "Exception thrown by analyzer '{0}' while processing '{1}'.", new object[] { analyzer.Name, document.SourceCode.Path });
this.data.Core.SignalOutput(MessageImportance.High, output);
throw;
}
}
}
}
}
/// <summary>
/// Checks the element headers within the given document.
/// </summary>
/// <param name="document">The document to check.</param>
public override void AnalyzeDocument(CodeDocument document)
{
Param.RequireNotNull(document, "document");
CsDocument csdocument = (CsDocument)document;
if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
{
this.CheckElementDocumentation(csdocument);
this.CheckFileHeader(csdocument);
this.CheckSingleLineComments(csdocument.RootElement);
}
}
/// <summary>
/// Runs the analyzers against the given document.
/// </summary>
/// <param name="document">The document to analyze.</param>
/// <param name="parser">The parser that created the document.</param>
/// <param name="analyzers">The analyzers to run against the document.</param>
/// <param name="passNumber">The current pass number.</param>
/// <returns>Returns true if analysis was run, or false if analysis was delayed until the next pass.</returns>
private bool TestAndRunAnalyzers(
CodeDocument document, SourceParser parser, IEnumerable<SourceAnalyzer> analyzers, int passNumber)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parser, "parser");
Param.Ignore(analyzers);
Param.Ignore(passNumber);
if (analyzers == null)
{
return true;
}
// Determine whether any of the analyzers wish to delay parsing until the next pass.
bool delay = false;
foreach (SourceAnalyzer analyzer in analyzers)
{
if (analyzer.DelayAnalysis(document, passNumber))
{
delay = true;
break;
}
}
if (!delay)
{
this.RunAnalyzers(document, parser, analyzers);
}
return !delay;
}
/// <summary>
/// Runs the list of analyzers against the given document.
/// </summary>
/// <param name="document">The document to analyze.</param>
/// <param name="parser">The parser that created the document.</param>
/// <param name="analyzers">The list of analyzsers to run against the document.</param>
private void RunAnalyzers(
CodeDocument document, SourceParser parser, IEnumerable<SourceAnalyzer> analyzers)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(parser, "parser");
Param.Ignore(analyzers, "analyzers");
if (analyzers != null)
{
if (parser.SkipAnalysisForDocument(document))
{
this.data.Core.SignalOutput(
MessageImportance.Normal,
string.Format(CultureInfo.CurrentCulture, "Skipping {0}...", document.SourceCode.Name));
}
else
{
// Loop through each of the analyzers attached to the parser.
foreach (SourceAnalyzer analyzer in analyzers)
{
// Make sure the user hasn't cancelled us.
if (this.data.Core.Cancel)
{
break;
}
SourceParser.ClearAnalyzerTags(document);
try
{
analyzer.AnalyzeDocument(document);
}
catch (System.Exception)
{
string details = string.Format(
CultureInfo.CurrentCulture,
"Exception thrown by analyzer '{0}' while processing '{1}'.",
analyzer.Name,
document.SourceCode.Path);
this.data.Core.SignalOutput(MessageImportance.High, details);
throw;
}
}
}
}
}
public abstract bool ParseFile(SourceCode sourceCode, int passNumber, ref CodeDocument document);
/// <summary>
/// Indicates whether to skip analyzis on the given document.
/// </summary>
/// <param name="document">The document.</param>
/// <returns>Returns true to skip analysis on the document.</returns>
public virtual bool SkipAnalysisForDocument(CodeDocument document)
{
Param.Ignore(document);
return false;
}
/// <summary>
/// Gets a value indicating whether the given rule is enabled for the given document.
/// </summary>
/// <param name="document">The document being analyzed.</param>
/// <param name="ruleName">The rule to check.</param>
/// <returns>Returns true if the rule is enabled; otherwise false.</returns>
public virtual bool IsRuleEnabled(CodeDocument document, string ruleName)
{
Param.Ignore(document, ruleName);
return true;
}
/// <summary>
/// Exports the violations found within this document into the given xml node.
/// </summary>
/// <param name="document">The document containing the violations.</param>
/// <param name="violationsDocument">The xml document in which to store the violation information.</param>
/// <param name="parentNode">The parent node within this xml document under which to store the violation information.</param>
internal static void ExportViolations(CodeDocument document, XmlDocument violationsDocument, XmlNode parentNode)
{
Param.AssertNotNull(document, "document");
Param.AssertNotNull(violationsDocument, "violationsDocument");
Param.AssertNotNull(parentNode, "parentNode");
if (document.DocumentContents != null)
{
SourceParser.ExportElementViolations(document.DocumentContents, violationsDocument, parentNode);
}
if (document.SourceCode != null)
{
// Add the violations from the source code.
foreach (Violation violation in document.SourceCode.Violations)
{
SourceParser.ExportViolation(violation, violationsDocument, parentNode);
}
}
}
