public void AnalyzeCodeBlockEnd(CodeBlockAnalysisContext context)
{
foreach (KeyValuePair <ISymbol, XmlDocumentEnvironment> p in _xmlDocumentEnvironments)
{
XmlDocumentEnvironment env = p.Value;
if (!(env.IsXmlResolverSet | env.IsSecureResolver))
{
Diagnostic diag = Diagnostic.Create(
RuleDoNotUseInsecureDTDProcessing,
env.XmlDocumentDefinition.GetLocation(),
SecurityDiagnosticHelpers.GetLocalizableResourceString(
nameof(DesktopAnalyzersResources.XmlDocumentWithNoSecureResolverMessage),
env.EnclosingConstructSymbol.Name));
context.ReportDiagnostic(diag);
}
}
foreach (KeyValuePair <ISymbol, XmlTextReaderEnvironment> p in _xmlTextReaderEnvironments)
{
XmlTextReaderEnvironment env = p.Value;
if (!(env.IsXmlResolverSet | env.IsSecureResolver) ||
!(env.IsDtdProcessingSet | env.IsDtdProcessingDisabled))
{
Diagnostic diag = Diagnostic.Create(
RuleDoNotUseInsecureDTDProcessing,
env.XmlTextReaderDefinition.GetLocation(),
SecurityDiagnosticHelpers.GetLocalizableResourceString(
nameof(DesktopAnalyzersResources.XmlTextReaderConstructedWithNoSecureResolutionMessage),
env.EnclosingConstructSymbol.Name));
context.ReportDiagnostic(diag);
}
}
}
public void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
if (IsEmptyFinalizer(context.CodeBlock, context.SemanticModel))
{
context.ReportDiagnostic(context.OwningSymbol.CreateDiagnostic(CA1821DiagnosticAnalyzerRule.Rule));
}
}
public void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
if (_analyzer.IsIgnoredCodeBlock(context.CodeBlock))
{
return;
}
var(completed, intervalTree) = _codeBlockIntervals.GetOrAdd(context.CodeBlock.SyntaxTree, _ => (new StrongBox <bool>(false), SimpleIntervalTree.Create(new TextSpanIntervalIntrospector(), Array.Empty <TextSpan>())));
if (completed.Value)
{
return;
}
RoslynDebug.AssertNotNull(intervalTree);
lock (completed)
{
if (completed.Value)
{
return;
}
if (intervalTree.HasIntervalThatOverlapsWith(context.CodeBlock.FullSpan.Start, context.CodeBlock.FullSpan.End))
{
return;
}
intervalTree.AddIntervalInPlace(context.CodeBlock.FullSpan);
}
_analyzer.AnalyzeCodeBlock(context);
}
private static void AnalyzeMethodDeclaration(CodeBlockAnalysisContext context)
{
MethodDeclarationSyntax methodSyntax = context.CodeBlock as MethodDeclarationSyntax;
IMethodSymbol method = context.OwningSymbol as IMethodSymbol;
if (method == null || methodSyntax == null)
{
return;
}
var baseTypeOverridingMethods = GetBaseTypeOverridingMethod(method);
var contractMethods = baseTypeOverridingMethods.SelectMany(o => GetContractTypeMethods(o, method)).ToList();
contractMethods.AddRange(baseTypeOverridingMethods.SelectMany(o => GetVirtualMethodsWithContracts(o, method)));
context.CancellationToken.ThrowIfCancellationRequested();
if (contractMethods.Count > 0)
{
var requireStatements = contractMethods.SelectMany(o => ExtractRequires(o, context.CancellationToken)).ToList();
requireStatements = DeduplicateRequires(requireStatements, ExtractRequires(methodSyntax, ExtractStatementsKind).ToList(), ExtractStatementsKind != ExtractStatements.Default);
if (requireStatements.Count > 0)
{
StringBuilder bldr = new StringBuilder();
foreach (var st in requireStatements)
{
bldr.AppendLine(st.ToString());
}
context.ReportDiagnostic(Diagnostic.Create(Rule, methodSyntax.Identifier.GetLocation(), bldr.ToString()));
}
}
}
public void ReportUnusedParameters(CodeBlockAnalysisContext codeBlockContext)
{
foreach (IParameterSymbol unusedParameter in _trackedParameters)
{
ReportUnusedParameter(codeBlockContext, unusedParameter);
}
}
private static void AnalyzeSymbol(CodeBlockAnalysisContext context)
{
// TODO: Replace the following code with your own analysis, generating Diagnostic objects for any issues you find
var ifs = context.CodeBlock.DescendantNodes().OfType <IfStatementSyntax>();
foreach (var ifstament in ifs)
{
if (ifstament.Condition is null)
{
continue;
}
if (ifstament.Condition.IsKind(SyntaxKind.NotEqualsExpression) || ifstament.Condition.IsKind(SyntaxKind.EqualsExpression) || ifstament.Condition.IsKind(SyntaxKind.IsExpression))
{
var binaryExpression = ifstament.Condition as BinaryExpressionSyntax;
if (binaryExpression == null)
{
return;
}
var left = binaryExpression.Left as LiteralExpressionSyntax;
var right = binaryExpression.Right as LiteralExpressionSyntax;
if (left != null && left.IsKind(SyntaxKind.NullLiteralExpression))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, ifstament.GetLocation()));
}
else if (right != null && right.IsKind(SyntaxKind.NullLiteralExpression))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, ifstament.GetLocation()));
}
}
}
}
private void AnalyzeMethodCodeBlock(CodeBlockAnalysisContext context, MethodDeclarationSyntax methodDeclarationSyntax)
{
if (HasMultipleIndentations(methodDeclarationSyntax.Body))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, methodDeclarationSyntax.Identifier.GetLocation(), methodDeclarationSyntax.Identifier.Text));
}
}
public void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
if (!suppress)
{
context.ReportDiagnostic(GetDiagnosticLocation(context.CodeBlock).CreateDiagnostic(Rule, context.OwningSymbol.Name));
}
}
//TODO: Look at cleaning this up and making it easier to register processors and fixers etc.
private void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
if (this.SupportedDiagnostics.Contains(AvailableDiagnostics.GenericTypeArgumentMissing.Rule))
{
AvailableDiagnostics.GenericTypeArgumentMissing.Analyzer.ProcessCodeBlock(context);
}
}
private void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
foreach (var elseClause in context.CodeBlock.DescendantNodes().OfType <ElseClauseSyntax>())
{
context.ReportDiagnostic(Diagnostic.Create(Rule, elseClause.GetLocation()));
}
}
private void AnalyzeMethodCodeBlock(CodeBlockAnalysisContext context, MethodDeclarationSyntax methodDeclarationSyntax)
{
if (HasMultipleIndentations(methodDeclarationSyntax.Body))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, methodDeclarationSyntax.Identifier.GetLocation(), methodDeclarationSyntax.Identifier.Text));
}
}
private void CodeBlockAction(CodeBlockAnalysisContext context)
{
foreach (var analyzer in AnalyzersByContextType[AnalysisContextType.CodeBlock])
{
(analyzer as DiagnosticBase <CodeBlockAnalysisContext>).Analyze(context);
}
}
internal static void HandleBlockTooLong(
CodeBlockAnalysisContext context,
ISet <SyntaxKind> supportedSyntaxKinds,
DiagnosticDescriptor descriptor,
int maxLineCount)
{
if (context.OwningSymbol.Kind == SymbolKind.Method)
{
SyntaxNode block = context.CodeBlock;
SyntaxKind blockKind = block.Kind();
if (supportedSyntaxKinds.Contains(blockKind))
{
SyntaxTree tree = block.SyntaxTree;
if (tree != null && tree.TryGetText(out SourceText treeText))
{
SourceText blockText = treeText.GetSubText(block.Span);
int blockLineCount = blockText.Lines.Count;
if (blockLineCount > maxLineCount)
{
Location location = block.GetFirstLineLocation();
string blockName = context.OwningSymbol.Name;
string blockDescription = GetBlockDescription(blockName, blockKind, context.OwningSymbol?.ContainingType?.Name);
context.ReportDiagnostic(Diagnostic.Create(descriptor, location, blockDescription, maxLineCount, blockLineCount));
}
}
}
}
}
private void AnalyzeMethodBlock(CodeBlockAnalysisContext blockContext, IMethodSymbol methodSymbol, AnalyzerConfig analyzerConfig)
{
var declaredThrowTypes = GetDeclaredTypes(methodSymbol);
var throwStatements = blockContext.CodeBlock.DescendantNodes().OfType <ThrowStatementSyntax>();
var offendingThrows = from thrw in throwStatements
let exType = blockContext.SemanticModel.GetTypeInfo(thrw.Expression).Type
where !exType.InheritsFromOrEqualsAny(declaredThrowTypes)
select(expression: thrw, type: exType);
var uncaughtThrows = from thrw in offendingThrows
where !blockContext.SemanticModel.IsCaught(thrw.type, thrw.expression)
select thrw;
foreach (var thrw in uncaughtThrows)
{
var exceptionType = thrw.type;
var diagnostic = Diagnostic.Create(
Rule,
thrw.expression.GetLocation(),
methodSymbol.Name,
exceptionType.Name
);
blockContext.ReportDiagnostic(diagnostic);
}
}
private static void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
SyntaxTrivia[] outerCommentTrivia = context.CodeBlock.GetLeadingTrivia().Concat(context.CodeBlock.GetTrailingTrivia())
.Where(IsComment).ToArray();
AnalyzeCommentTrivia(outerCommentTrivia, context);
}
private void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
foreach (var elseClause in context.CodeBlock.DescendantNodes().OfType<ElseClauseSyntax>())
{
context.ReportDiagnostic(Diagnostic.Create(Rule, elseClause.GetLocation()));
}
}
private void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
var method = context.CodeBlock as MethodDeclarationSyntax;
if (method == null)
{
return;
}
if (method.Body != null)
{
foreach (var statement in method.Body.Statements.OfType <ExpressionStatementSyntax>())
{
var diagnostic = AnalyzeExpression(statement.Expression);
if (diagnostic != null)
{
context.ReportDiagnostic(diagnostic);
}
}
return;
}
if (method.ExpressionBody != null)
{
var diagnostic = AnalyzeExpression(method.ExpressionBody.Expression);
if (diagnostic != null)
{
context.ReportDiagnostic(diagnostic);
}
}
}
private void AnalyzeCodeBlock(CodeBlockAnalysisContext context, PXContext pxContext)
{
context.CancellationToken.ThrowIfCancellationRequested();
// Get body from a method or property
CSharpSyntaxNode body = context.CodeBlock?.GetBody();
if (body == null)
{
return;
}
// Collect all PXGraph-typed method parameters passed to BQL queries
var walker = new BqlGraphArgWalker(context.SemanticModel, pxContext);
body.Accept(walker);
if (walker.GraphArguments.IsEmpty)
{
return;
}
// Collect all available PXGraph instances (@this, method parameters, local variables)
var existingGraphs = GetExistingGraphInstances(body, context.SemanticModel, pxContext);
if (existingGraphs.IsEmpty)
{
return;
}
// Determine if available PXGraph instance is used outside of BQL queries
var usedGraphs = GetSymbolUsages(body, existingGraphs, context.SemanticModel, walker.GraphArguments)
.ToImmutableHashSet();
var availableGraphs = existingGraphs.Except(usedGraphs).ToArray();
// Analyze each PXGraph-typed parameter in BQL queries
foreach (var graphArgSyntax in walker.GraphArguments)
{
var instantiationType = graphArgSyntax.GetGraphInstantiationType(context.SemanticModel, pxContext);
// New PXGraph() / new TGraph() / PXGraph.CreateInstance<TGraph> are reported at all times
// All other usages are reported only if:
// 1. There is at least one existing PXGraph instance available
// 2. PXGraph parameter is not used in any way because its modifications might affect the BQL query results
if (instantiationType != GraphInstantiationType.None)
{
context.ReportDiagnosticWithSuppressionCheck(Diagnostic.Create(Descriptors.PX1072_PXGraphCreationForBqlQueries,
graphArgSyntax.GetLocation(),
CreateDiagnosticProperties(availableGraphs, pxContext)),
pxContext.CodeAnalysisSettings);
}
else if (availableGraphs.Length > 0 && context.SemanticModel.GetSymbolInfo(graphArgSyntax).Symbol is ILocalSymbol localVar &&
!usedGraphs.Contains(localVar))
{
context.ReportDiagnosticWithSuppressionCheck(Diagnostic.Create(Descriptors.PX1072_PXGraphCreationForBqlQueries,
graphArgSyntax.GetLocation(),
CreateDiagnosticProperties(availableGraphs.Where(g => !Equals(g, localVar)), pxContext)),
pxContext.CodeAnalysisSettings);
}
}
}
public ReportingContext(CodeBlockAnalysisContext context, Diagnostic diagnostic)
{
SyntaxTree = context.GetSyntaxTree();
Compilation = context.SemanticModel.Compilation;
Diagnostic = diagnostic;
this.contextSpecificReport = context.ReportDiagnostic;
}
private void AnalyzeCodeBlock(CodeBlockAnalysisContext blockContext, AnalyzerConfig analyzerConfig)
{
if (blockContext.OwningSymbol is IMethodSymbol methodSymbol &&
analyzerConfig.ShouldAnalyze(methodSymbol.ContainingType))
{
AnalyzeMethodBlock(blockContext, methodSymbol, analyzerConfig);
}
}
protected void CheckNumberOfParameters(CodeBlockAnalysisContext obj, int numberOfParameters, IMethodSettings methodSettings)
{
if (numberOfParameters < 4)
return;
var diagnostic = Diagnostic.Create(ParametersRule, obj.CodeBlock.GetLocation(), new object[] { "Number Of Parameters", 3 });
obj.ReportDiagnostic(diagnostic);
}
private static void ReportAtContainingSymbol(int statementCount, CodeBlockAnalysisContext context)
{
string kind = GetMemberKind(context.OwningSymbol, context.CancellationToken);
string memberName = context.OwningSymbol.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat);
Location location = GetMemberLocation(context.OwningSymbol, context.SemanticModel, context.CancellationToken);
context.ReportDiagnostic(Diagnostic.Create(Rule, location, kind, memberName, statementCount));
}
protected void CheckLinesOfCode(CodeBlockAnalysisContext obj, int linesOfCode, IMethodSettings methodSettings)
{
if (linesOfCode < 20)
return;
var diagnostic = Diagnostic.Create(LinesRule, obj.CodeBlock.GetLocation(), new object[] { "Lines Of Code", 20 });
obj.ReportDiagnostic(diagnostic);
}
protected void CheckComplexity(CodeBlockAnalysisContext obj, int cyclomaticComplexity, IMethodSettings methodSettings)
{
if (cyclomaticComplexity < 10)
return;
var diagnostic = Diagnostic.Create(ComplexityRule, obj.CodeBlock.GetLocation(), new object[]{ "Cyclomatic Complexity", 10});
obj.ReportDiagnostic(diagnostic);
}
public void CodeBlockEndAction(CodeBlockAnalysisContext context)
{
// Report diagnostics for unused parameters.
foreach (IParameterSymbol parameter in _unusedParameters)
{
Diagnostic diagnostic = Diagnostic.Create(Rule, parameter.Locations[0], parameter.Name, parameter.ContainingSymbol.Name);
context.ReportDiagnostic(diagnostic);
}
}
private static void Analyze(CodeBlockAnalysisContext context)
{
// block contains OpenTK.Graphics.OpenGL
var walker = new BlockWalker();
walker.Visit(context.CodeBlock);
foreach (var diagnostic in walker.Diagnostics)
{
context.ReportDiagnostic(diagnostic);
}
}
protected override ImmutableArray <Diagnostic> AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
var semanticModel = context.SemanticModel;
var cancellationToken = context.CancellationToken;
var options = context.GetCSharpAnalyzerOptions().GetSimplifierOptions();
using var simplifier = new TypeSyntaxSimplifierWalker(this, semanticModel, options, ignoredSpans: null, cancellationToken);
simplifier.Visit(context.CodeBlock);
return(simplifier.Diagnostics);
}
private static void Action(CodeBlockAnalysisContext context)
{
var blockSyntaxes = context.CodeBlock.ChildNodes().OfType <BlockSyntax>();;
var switchStatements = blockSyntaxes.SelectMany(x => x.Statements.OfType <SwitchStatementSyntax>());
foreach (var switchStatement in switchStatements)
{
CheckSwitch(switchStatement, context);
}
}
async void Analyzeblock(CodeBlockAnalysisContext obj)
{
var metricsCalculator = new CodeMetricsCalculator();
var metrics = await metricsCalculator.Calculate(new List<SyntaxTree> { CSharpSyntaxTree.ParseText(obj.CodeBlock.ToString()) });
var functionMetric = metrics.ElementAt(0).TypeMetrics.ElementAt(0).MemberMetrics.ElementAt(0);
//var settings = SettingsHelper.GetSettings(obj.Options);
var settings = new Settings();
CheckComplexity(obj, functionMetric.CyclomaticComplexity, settings.MethodSettings);
CheckNumberOfParameters(obj, functionMetric.NumberOfParameters, settings.MethodSettings);
CheckLinesOfCode(obj, functionMetric.LinesOfCode, settings.MethodSettings);
}
private static void Analyze(CodeBlockAnalysisContext context)
{
// block contains OpenTK.Graphics.OpenGL
var walker = new BlockWalker();
walker.Visit(context.CodeBlock);
foreach (var diagnostic in walker.Diagnostics)
{
context.ReportDiagnostic(diagnostic);
}
}
protected override ImmutableArray <Diagnostic> AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
var semanticModel = context.SemanticModel;
var cancellationToken = context.CancellationToken;
var syntaxTree = semanticModel.SyntaxTree;
var optionSet = context.Options.GetAnalyzerOptionSet(syntaxTree, cancellationToken);
var simplifier = new TypeSyntaxSimplifierWalker(this, semanticModel, optionSet, ignoredSpans: null, cancellationToken);
simplifier.Visit(context.CodeBlock);
return(simplifier.Diagnostics);
}
public void AnalyzeCodeBlockEnd(CodeBlockAnalysisContext context)
{
foreach (var pair in _catchAllCatchClauses)
{
context.ReportDiagnostic(
Diagnostic.Create(
Rule,
pair.Key.GetLocation(),
_owningSymbol.ToDisplayString(),
pair.Value.ToDisplayString()));
}
}
private void ReportUnusedParameter(CodeBlockAnalysisContext codeBlockContext, IParameterSymbol unusedParameter)
{
// I've seen it empty when the parameter list is being edited.
if (unusedParameter.DeclaringSyntaxReferences.Length == 0)
{
return;
}
SyntaxReference syntaxReference = unusedParameter.DeclaringSyntaxReferences[0];
Diagnostic diagnostic = Diagnostic.Create(_rule, syntaxReference.SyntaxTree.GetLocation(syntaxReference.Span), unusedParameter.Name);
codeBlockContext.ReportDiagnostic(diagnostic);
}
private static BlockSyntax GetBody(CodeBlockAnalysisContext context)
{
switch (context.CodeBlock)
{
case MethodDeclarationSyntax s: return(s.Body);
case ConstructorDeclarationSyntax s: return(s.Body);
case AccessorDeclarationSyntax s: return(s.Body);
default: return(null);
}
}
private static void AnalyzeSymbol(CodeBlockAnalysisContext context)
{
// TODO: Replace the following code with your own analysis, generating Diagnostic objects for any issues you find
var ifs = context.CodeBlock.DescendantNodes().OfType <IfStatementSyntax>();
foreach (var ifstament in ifs)
{
foreach (var nestedif in ifstament.DescendantNodes().OfType <IfStatementSyntax>())
{
context.ReportDiagnostic(Diagnostic.Create(Rule, nestedif.GetLocation()));
}
}
}
private static void AnalyzeSymbol(CodeBlockAnalysisContext context)
{
// TODO: Replace the following code with your own analysis, generating Diagnostic objects for any issues you find
var returns = context.CodeBlock.DescendantNodes().OfType <ReturnStatementSyntax>();
foreach (var r in returns)
{
foreach (var item in r.DescendantTokens().Where(x => x.IsKind(SyntaxKind.NullKeyword)))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, item.GetLocation()));
}
}
}
private static void ProcessSwitchCases <T>(
Func <bool> shouldProceedFunc,
Func <IEnumerable <SwitchArgumentTypeItem <T> > > allImplementationsFunc,
Func <IEnumerable <string> > caseImplementationFunc,
DiagnosticDescriptor rule,
Location location,
CodeBlockAnalysisContext context,
int switchStatementLocation) where T : IComparable
{
if (shouldProceedFunc == null ||
allImplementationsFunc == null ||
caseImplementationFunc == null ||
rule == null)
{
return;
}
if (!shouldProceedFunc())
{
return;
}
var allImplementations = allImplementationsFunc().ToList();
var obj = new object();
var caseImplementations = caseImplementationFunc().ToDictionary(x => x, _ => obj);
var checkedValues = allImplementations
.Where(expectedValue => caseImplementations.ContainsKey(expectedValue.FullName))
.ToDictionary(x => x.Value, x => obj);
var notCheckedValues = allImplementations.Where(x =>
!checkedValues.ContainsKey(x.Value))
.OrderBy(x => x.FullName)
.ToList();
if (notCheckedValues.Any())
{
var firstUncheckedValue = notCheckedValues.First();
var typeName = firstUncheckedValue.Member;
var symbols = context.SemanticModel.LookupSymbols(switchStatementLocation);
var shouldAddNamespace = !symbols.Any(x => x.Name == typeName && x.ContainingNamespace.Name == firstUncheckedValue.Prefix);
var notCoveredValues = notCheckedValues.Select(caseName =>
BuildName(shouldAddNamespace, caseName.Prefix, caseName.FullName));
var diagnostic = Diagnostic.Create(rule, location, string.Join(", ", notCoveredValues));
context.ReportDiagnostic(diagnostic);
}
string BuildName(bool shouldAddPrefix, string prefix, string fullName) => shouldAddPrefix ? $"{prefix}.{fullName}" : fullName;
}
private static void Analyze(CodeBlockAnalysisContext context)
{
if (context.OwningSymbol.Kind != SymbolKind.Method)
{
return;
}
var method = (IMethodSymbol)context.OwningSymbol;
foreach (var parameter in method.Parameters)
{
if (parameter.Type.AllInterfaces.Select(x => x.MetadataName).Contains("IInternalActor"))
{
var diag = Diagnostic.Create(Rule, parameter.Locations[0], parameter.Name,
parameter.ContainingSymbol.Name);
context.ReportDiagnostic(diag);
}
}
}
private static void CodeBlockAction(CodeBlockAnalysisContext codeBlockContext)
{
// We only care about method bodies.
if (codeBlockContext.OwningSymbol.Kind != SymbolKind.Method)
{
return;
}
// Report diagnostic for void non-virtual methods with empty method bodies.
var method = (IMethodSymbol)codeBlockContext.OwningSymbol;
var block = (BlockSyntax)codeBlockContext.CodeBlock.ChildNodes().FirstOrDefault(n => n.Kind() == SyntaxKind.Block);
if (method.ReturnsVoid && !method.IsVirtual && block != null && block.Statements.Count == 0)
{
var tree = block.SyntaxTree;
var location = method.Locations.First(l => tree.Equals(l.SourceTree));
var diagnostic = Diagnostic.Create(Rule, location, method.Name);
codeBlockContext.ReportDiagnostic(diagnostic);
}
}
public static void OnCodeBlockEnded(CodeBlockAnalysisContext context)
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(Descriptor1, Location.None));
}
public CodeBlockAnalyzer(CodeBlockAnalysisContext context)
{
this.context = context;
}
private static void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
new CodeBlockAnalyzer(context).Analyze(context.CodeBlock);
}
/// <summary>
/// Analyzes a code block.
/// </summary>
/// <param name="context">The context.</param>
private void AnalyzeCodeBlock(CodeBlockAnalysisContext context)
{
var owner = context.OwningSymbol;
var block = context.CodeBlock;
var model = context.SemanticModel;
// Look over the object for debugging
var inspect = context;
// TODO: Tell Alfred
}
public void CodeBlockEndAction(CodeBlockAnalysisContext context)
{
// Report diagnostics for unused parameters.
foreach (var parameter in _unusedParameters)
{
var diagnostic = Diagnostic.Create(Rule, parameter.Locations[0], parameter.Name, parameter.ContainingSymbol.Name);
context.ReportDiagnostic(diagnostic);
}
}
/// <summary>
/// Analyzes the code block.
/// </summary>
/// <param name="codeBlockAnalysisContext">The code block analysis context.</param>
private static void AnalyzeCodeBlock(CodeBlockAnalysisContext codeBlockAnalysisContext)
{
if (!(codeBlockAnalysisContext.CodeBlock is MethodDeclarationSyntax))
{
MemberDeclarationSyntax declaration = (MemberDeclarationSyntax)codeBlockAnalysisContext.CodeBlock;
if (!declaration.HasLeadingTrivia)
{
string memberName = new Parser().GetMemberName(declaration);
Diagnostic diagnostic = Diagnostic.Create(CodocExtensionAnalyzer.Rule, declaration.GetLocation(), memberName);
codeBlockAnalysisContext.ReportDiagnostic(diagnostic);
}
}
}
