public PreOccurence MakeVConfList(AnalysisConfig config, Checker checker, CSharpSyntaxNode raw, List <string> args)
{
var lineSpan = raw.GetLocation().GetLineSpan();
PreOccurence preOcc = DexterDependUtil.MakePreOccurence(raw, lineSpan, args, checker, config, CheckerName, Description);
return(preOcc);
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var propertyRaws = syntaxRoot.DescendantNodes().OfType <PropertyDeclarationSyntax>();
if (!propertyRaws.Any())
{
return;
}
foreach (var propertyRaw in propertyRaws)
{
string propertyName = propertyRaw.Identifier.ToString();
if (pascalCasing.HasDefect(propertyName))
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, propertyRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (DexterUtil.IsPropertyDeclarationBoolean(propertyRaw))
{
if (booleanPropertyPrefixing.HasDefect(propertyName))
{
PreOccurence preOcc = booleanPropertyPrefixing.MakeDefect(config, checker, propertyRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var interfaceRaws = syntaxRoot.DescendantNodes().OfType <InterfaceDeclarationSyntax>();
if (!interfaceRaws.Any())
{
return;
}
foreach (var interfaceRaw in interfaceRaws)
{
string interfaceName = interfaceRaw.Identifier.ToString();
if (prefixNaming.HasDefect(new NamingSet
{
currentName = interfaceName,
basicWord = "I"
}))
{
PreOccurence preOcc = prefixNaming.MakeDefect(config, checker, interfaceRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (underscore.HasDefect(interfaceName)) // Underscore Naming
{
PreOccurence preOcc = underscore.MakeDefect(config, checker, interfaceRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (pascalCasing.HasDefect(interfaceName))
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, interfaceRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public PreOccurence MakeDefect(AnalysisConfig config, Checker checker, CSharpSyntaxNode raw)
{
var lineSpan = raw.GetLocation().GetLineSpan();
PreOccurence preOcc = DexterCRCUtil.MakePreOccurence(raw, lineSpan, checker, config, CheckerName, Description);
return(preOcc);
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var classRaws = syntaxRoot.DescendantNodes().OfType <UsingDirectiveSyntax>();
if (!classRaws.Any())
{
return;
}
int count = 0;
foreach (var classRaw in classRaws)
{
string heading = classRaw.GetLeadingTrivia().ToList().ToString();
if (!headingRule.HasDefect(heading))
{
count = count++;
}
}
if (count == 0)
{
PreOccurence preOcc = headingRule.MakeDefect(config, checker, classRaws.ToList()[0]);
result.AddDefectWithPreOccurence(preOcc);
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var eventRaws = syntaxRoot.DescendantNodes().OfType <EventFieldDeclarationSyntax>();
foreach (var eventRaw in eventRaws)
{
string eventTypeName = eventRaw.Declaration.Type.ToString();
if (suffixNaming.HasDefect(new NamingSet
{
currentName = eventTypeName,
basicWord = DexterCRCUtil.EVENT_TYPE_SUFFIX
}))
{
PreOccurence preOcc = suffixNaming.MakeDefect(config, checker, eventRaw);
result.AddDefectWithPreOccurence(preOcc);
}
List <string> variables = GetCamelCasingVariables(eventRaw.Declaration.Variables);
foreach (string variable in variables)
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, eventRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var statementRaws = syntaxRoot.DescendantNodes().OfType <ObjectCreationExpressionSyntax>();
if (!statementRaws.Any())
{
return;
}
char delimiters = ',';
string[] subMethod = checker.Properties.Value.Split(delimiters);
List <string> subMethodList = new List <string>();
subMethodList.AddRange(subMethod);
foreach (var statementRaw in statementRaws)
{
string statement = statementRaw.ToString();
if (messageMethod.HasVconfMethod(subMethodList, statement))
{
List <string> args = new List <string>(2)
{
"", ""
};
PreOccurence preOcc = messageMethod.MakeVConfList(config, checker, statementRaw, args);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var methodRaws = syntaxRoot.DescendantNodes().OfType <MethodDeclarationSyntax>();
if (!methodRaws.Any())
{
return;
}
foreach (var methodRaw in methodRaws)
{
string methodName = methodRaw.Identifier.ToString();
if (withoutUnderscore.HasDefect(methodName))
{
PreOccurence preOcc = withoutUnderscore.MakeDefect(config, checker, methodRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (pascalCasing.HasDefect(methodName))
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, methodRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (verbNaming.HasDefect(methodName))
{
PreOccurence preOcc = verbNaming.MakeDefect(config, checker, methodRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var delegateRaws = syntaxRoot.DescendantNodes().OfType <DelegateDeclarationSyntax>();
foreach (var delegateRaw in delegateRaws)
{
var delegateName = delegateRaw.Identifier.ToString();
if (pascalCasing.HasDefect(delegateName))
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, delegateRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (!suffixNaming.HasDefect(new NamingSet
{
currentName = delegateName,
basicWord = DexterCRCUtil.DELEGATE_SUFFIX
}))
{
PreOccurence preOcc = suffixNaming.MakeDefect(config, checker, delegateRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var foreachRaws = syntaxRoot.DescendantNodes().OfType <ForEachStatementSyntax>();
foreach (var foreachRaw in foreachRaws)
{
if (bracket.HasDefect(foreachRaw.Statement.ToString()))
{
PreOccurence preOcc = bracket.MakeDefect(config, checker, foreachRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var namespaceRaws = syntaxRoot.DescendantNodes().OfType <NamespaceDeclarationSyntax>();
foreach (var namespaceRaw in namespaceRaws)
{
string namespaceName = namespaceRaw.Name.ToString();
if (pascalCasing.HasDefect(namespaceName))
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, namespaceRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var baseFieldRaws = syntaxRoot.DescendantNodes().OfType <FieldDeclarationSyntax>();
foreach (var fieldRaw in baseFieldRaws)
{
if (HasFieldModifier(fieldRaw.Modifiers) &&
HasCamelCasingDefect(fieldRaw.Declaration.Variables))
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, fieldRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var enumRaws = syntaxRoot.DescendantNodes().OfType <EnumDeclarationSyntax>();
foreach (var enumRaw in enumRaws)
{
var enumName = enumRaw.Identifier.ToString();
if (pascalCasing.HasDefect(enumName))
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, enumRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var whileRaws = syntaxRoot.DescendantNodes().OfType <WhileStatementSyntax>();
if (!whileRaws.Any())
{
return;
}
foreach (var whileRaw in whileRaws)
{
if (bracket.HasDefect(whileRaw.Statement.ToString()))
{
PreOccurence preOcc = bracket.MakeDefect(config, checker, whileRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var parameterRaws = syntaxRoot.DescendantNodes().OfType <ParameterSyntax>();
if (!parameterRaws.Any())
{
return;
}
foreach (var parameterRaw in parameterRaws)
{
string parameterName = parameterRaw.Identifier.ValueText;
if (camelCasing.HasDefect(parameterName))
{
PreOccurence preOcc = camelCasing.MakeDefect(config, checker, parameterRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var methodRaws = syntaxRoot.DescendantNodes().OfType <MethodDeclarationSyntax>();
if (!methodRaws.Any())
{
return;
}
foreach (var methodRaw in methodRaws)
{
SyntaxTriviaList syntaxTriviaList = methodRaw.GetLeadingTrivia();
if (methodSpacing.HasDefect(syntaxTriviaList))
{
PreOccurence preOcc = methodSpacing.MakeDefect(config, checker, methodRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var commentRaws = syntaxRoot.DescendantNodes().OfType <XmlCommentSyntax>();
if (!commentRaws.Any())
{
return;
}
foreach (var commentRaw in commentRaws)
{
if (commentRules.HasDefect(commentRaws))
{
PreOccurence preOcc = commentRules.MakeDefect(config, checker, commentRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
throw new NotImplementedException();
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var classRaws = syntaxRoot.DescendantNodes().OfType <ClassDeclarationSyntax>();
if (!classRaws.Any())
{
return;
}
foreach (var classRaw in classRaws)
{
string className = classRaw.Identifier.ToString();
if (underscore.HasDefect(className))
{
PreOccurence preOcc = underscore.MakeDefect(config, checker, classRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (pascalCasing.HasDefect(className))
{
PreOccurence preOcc = pascalCasing.MakeDefect(config, checker, classRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (nounNaming.HasDefect(className))
{
PreOccurence preOcc = nounNaming.MakeDefect(config, checker, classRaw);
result.AddDefectWithPreOccurence(preOcc);
}
if (classRaw.BaseList == null)
{
continue;
}
else if (HasBaseTypeNamingDefect(className, classRaw.BaseList.Types))
{
PreOccurence preOcc = suffixNaming.MakeDefect(config, checker, classRaw);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
public void Analyze(AnalysisConfig config, AnalysisResult result, Checker checker, SyntaxNode syntaxRoot)
{
var statementRaws = syntaxRoot.DescendantNodes().OfType <InvocationExpressionSyntax>();
if (!statementRaws.Any())
{
return;
}
char delimiters = ',';
string[] subMethod = checker.Properties.Value.Split(delimiters);
List <string> subMethodList = new List <string>();
subMethodList.AddRange(subMethod);
foreach (var statementRaw in statementRaws)
{
string statement = statementRaw.ToString();
if (vconfMethod.HasVconfMethod(subMethodList, statement))
{
List <string> args = statementRaw.ArgumentList.Arguments.Select(s => s.ToString().Replace("\"", "")).ToList();
args.Add(""); // Vconf get only 1 arg
List <string> declaredVariables = syntaxRoot.DescendantNodes().OfType <FieldDeclarationSyntax>().Select(d => d.Declaration.Variables.ToString()).ToList();
var resultList = declaredVariables.Where(r => r.StartsWith(args[0]));
foreach (string s in resultList)
{
string[] declaredArr = s.Split('=');
if (declaredArr.Length == 2)
{
args[0] = declaredArr[1].Trim().Replace("\"", "");
}
}
PreOccurence preOcc = vconfMethod.MakeVConfList(config, checker, statementRaw, args);
result.AddDefectWithPreOccurence(preOcc);
}
}
}
internal static PreOccurence MakePreOccurence(CSharpSyntaxNode raw, FileLinePositionSpan lineSpan,
List <string> args, Checker checker, AnalysisConfig config, string baseCheckerName, string baseDescription)
{
PreOccurence preOcc = new PreOccurence();
preOcc.CheckerCode = checker.Code + baseCheckerName;
preOcc.FileName = config.FileName;
preOcc.ModulePath = config.ModulePath;
preOcc.ClassName = GetClassName(raw.AncestorsAndSelf().OfType <ClassDeclarationSyntax>());
preOcc.MethodName = GetMethodName(raw.AncestorsAndSelf().OfType <MethodDeclarationSyntax>());
preOcc.Language = config.GetLanguageEnum().ToString();
preOcc.SeverityCode = checker.SeverityCode;
preOcc.CategoryName = checker.CategoryName;
preOcc.Message = GetOccurenceMessage(baseDescription, checker.Name);
preOcc.ToolName = ToolName;
preOcc.StartLine = lineSpan.StartLinePosition.Line + 1;
preOcc.EndLine = lineSpan.EndLinePosition.Line + 1;
preOcc.CharStart = lineSpan.StartLinePosition.Character;
preOcc.CharEnd = lineSpan.EndLinePosition.Character;
preOcc.VariableName = (!string.IsNullOrEmpty(args[0])) ? args[0] : "";
preOcc.StringValue = (!string.IsNullOrEmpty(args[1])) ? args[1] : "";
return(preOcc);
}
