public void RegisterSyntaxNodeAction(CodeBlockStartAnalysisContext <SyntaxKind> c)
{
c.RegisterSyntaxNodeAction(
VisitSyntaxNode,
SyntaxKind.InvocationExpression,
SyntaxKind.ObjectCreationExpression,
SyntaxKind.SimpleAssignmentExpression,
SyntaxKind.VariableDeclarator);
}
public void Initialize(CodeBlockStartAnalysisContext <TLanguageKindEnum> context)
{
var methodSymbol = context.OwningSymbol as IMethodSymbol;
if (methodSymbol != null &&
methodSymbol.ReturnType.OriginalDefinition == _genericEnumerableSymbol)
{
GetSyntaxAnalyzer(context, _genericEnumerableSymbol, _genericEmptyEnumerableSymbol);
}
}
protected override void RegisterAnalyzer(CodeBlockStartAnalysisContext <SyntaxKind> context, CompilationSecurityTypes types, Version frameworkVersion)
{
CSharpAnalyzer analyzer = new CSharpAnalyzer(types, CSharpSyntaxNodeHelper.Default, frameworkVersion);
context.RegisterSyntaxNodeAction(
analyzer.AnalyzeNode,
SyntaxKind.InvocationExpression,
SyntaxKind.ObjectCreationExpression,
SyntaxKind.SimpleAssignmentExpression,
SyntaxKind.VariableDeclarator);
context.RegisterCodeBlockEndAction(analyzer.AnalyzeCodeBlockEnd);
}
protected override SyntaxNodeAnalyzer GetAnalyzer(CodeBlockStartAnalysisContext <SyntaxKind> context, CompilationSecurityTypes types)
{
SyntaxNodeAnalyzer analyzer = new SyntaxNodeAnalyzer(types, CSharpSyntaxNodeHelper.Default);
context.RegisterSyntaxNodeAction(
analyzer.AnalyzeNode,
SyntaxKind.InvocationExpression,
SyntaxKind.ObjectCreationExpression,
SyntaxKind.SimpleAssignmentExpression,
SyntaxKind.VariableDeclarator);
return(analyzer);
}
public void Initialize(CodeBlockStartAnalysisContext <TLanguageKindEnum> context)
{
_container.OnAbstractMember(
"CodeBlockStart",
context.CodeBlock,
context.OwningSymbol
);
context.RegisterCodeBlockEndAction(_container.AnalyzeCodeBlock);
context.RegisterSyntaxNodeAction(
_container.AnalyzeNode,
TestDiagnosticAnalyzer <TLanguageKindEnum> .AllSyntaxKinds.ToArray()
);
}
public void Initialize(CodeBlockStartAnalysisContext <VisualBasic.SyntaxKind> analysisContext)
{
analysisContext.RegisterCodeBlockEndAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_rule, context.OwningSymbol.Locations.First(), messageArgs: context.OwningSymbol.Name + ":end"));
});
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_rule, context.Node.GetLocation(), messageArgs: context.Node.ToFullString()));
},
VisualBasic.SyntaxKind.InvocationExpression);
}
private void AddDeclaredLocalVariables(CodeBlockStartAnalysisContext context)
{
foreach (VariableDeclarationBaseSyntax variable in ((MethodOrTriggerDeclarationSyntax)context.CodeBlock).Variables.Variables)
{
if (variable.IsKind(SyntaxKind.VariableListDeclaration))
{
foreach (VariableDeclarationNameSyntax variableName in ((VariableListDeclarationSyntax)variable).VariableNames)
{
this.localVariables.Add(variableName.GetNameStringValue(), variable);
}
break;
}
this.localVariables.Add(variable.GetNameStringValue(), variable);
}
}
public void Initialize(CodeBlockStartAnalysisContext <CSharp.SyntaxKind> analysisContext)
{
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(Desciptor2, Location.None));
},
CSharp.SyntaxKind.EqualsValueClause);
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(Desciptor3, Location.None));
},
CSharp.SyntaxKind.BaseConstructorInitializer);
}
private void CreateAnalyzerWithinCodeBlock(CodeBlockStartAnalysisContext<SyntaxKind> context)
{
var methodDeclaration = context.OwningSymbol as IMethodSymbol;
if (methodDeclaration != null)
{
ITypeSymbol cancellationTokenType = context.SemanticModel.Compilation.GetTypeByMetadataName("System.Threading.CancellationToken");
var paramTypes = methodDeclaration.Parameters.Select(x => x.Type);
if (paramTypes.Contains(cancellationTokenType))
{
// Analyze the inside of the code block for invocationexpressions
context.RegisterSyntaxNodeAction(new CancellationAnalyzer_Inner().AnalyzeNode, SyntaxKind.InvocationExpression);
}
}
}
public void CollectDeclaredLocalVariables(CodeBlockStartAnalysisContext context)
{
switch (context.CodeBlock.Kind)
{
case SyntaxKind.TriggerDeclaration:
if (((MethodOrTriggerDeclarationSyntax)context.CodeBlock).Variables == null)
{
break;
}
this.AddDeclaredLocalVariables(context);
break;
case SyntaxKind.MethodDeclaration:
this.AddDeclaredLocalVariables(context);
break;
}
}
private void CreateAnalyzerWithinCodeBlock(CodeBlockStartAnalysisContext <SyntaxKind> context)
{
var methodDeclaration = context.OwningSymbol as IMethodSymbol;
if (methodDeclaration != null)
{
ITypeSymbol cancellationTokenType = context.SemanticModel.Compilation.GetTypeByMetadataName("System.Threading.CancellationToken");
var paramTypes = methodDeclaration.Parameters.Select(x => x.Type);
if (paramTypes.Contains(cancellationTokenType))
{
// Analyze the inside of the code block for invocationexpressions
context.RegisterSyntaxNodeAction(new CancellationAnalyzer_Inner().AnalyzeNode, SyntaxKind.InvocationExpression);
}
}
}
private void AnalyzeCodeBlock(CodeBlockStartAnalysisContext <SyntaxKind> codeBlockStartContext)
{
if (!codeBlockStartContext.CodeBlock.IsKind(SyntaxKind.MethodDeclaration) && !codeBlockStartContext.CodeBlock.IsKind(SyntaxKind.ConstructorDeclaration))
{
return;
}
IMethodSymbol methodSymbol = codeBlockStartContext.OwningSymbol as IMethodSymbol;
if (!(methodSymbol?.Parameters.Length > 0) || methodSymbol.IsOverride || methodSymbol.IsVirtual || methodSymbol.IsEntryPoint() || methodSymbol.ImplementsInterface())
{
return;
}
ParameterTracker tracker = new ParameterTracker(methodSymbol.Parameters);
codeBlockStartContext.RegisterCodeBlockEndAction(codeBlockContext => tracker.ReportUnusedParameters(codeBlockContext));
codeBlockStartContext.RegisterSyntaxNodeAction(nodeContext => tracker.TryDiscardReferencedParameter(nodeContext), SyntaxKind.IdentifierName);
}
private static void AnalyzeUpdateCodeBlocks(CodeBlockStartAnalysisContext <SyntaxKind> context)
{
// If the current code block is not of a method, then stop analysis
if (context.OwningSymbol.Kind != SymbolKind.Method)
{
return;
}
// If the method block does not return void and is not one of the repeating unity callback functions we care about (ex: Update()), then stop analysis
var method = (IMethodSymbol)context.OwningSymbol;
if (!method.ReturnsVoid || !Consts.RepeatingUnityCallbacksFunctions.Contains(method.Name))
{
return;
}
// Launch our sub analyzers to search for method invocations and member access expressions
context.RegisterSyntaxNodeAction(IdentifyExpensiveFuncsAnalysis, SyntaxKind.InvocationExpression);
context.RegisterSyntaxNodeAction(IdentifyExpensiveAccessAnalysis, SyntaxKind.SimpleMemberAccessExpression);
}
public void Initialize(CodeBlockStartAnalysisContext <CSharp.SyntaxKind> analysisContext)
{
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(Desciptor2, Location.None));
},
CSharp.SyntaxKind.EqualsValueClause);
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(Desciptor3, Location.None));
},
CSharp.SyntaxKind.BaseConstructorInitializer);
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
DiagnosticDescriptor descriptor;
switch (context.Node.Parent.Kind())
{
case SyntaxKind.PropertyDeclaration:
descriptor = Desciptor4;
break;
case SyntaxKind.IndexerDeclaration:
descriptor = Desciptor5;
break;
default:
descriptor = Desciptor6;
break;
}
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(descriptor, Location.None));
},
CSharp.SyntaxKind.ArrowExpressionClause);
}
internal void CodeBlockStart(CodeBlockStartAnalysisContext <TLanguageKindEnum> context)
{
var method = context.OwningSymbol as IMethodSymbol;
if (method == null)
{
return;
}
INamedTypeSymbol namedType = method.ContainingType;
if (!namedType.DerivesFrom(_codeFixProviderSymbol))
{
return;
}
context.RegisterSyntaxNodeAction(invocationContext =>
{
var invocationSym = invocationContext.SemanticModel.GetSymbolInfo(invocationContext.Node).Symbol as IMethodSymbol;
if (invocationSym != null && _createMethods.Contains(invocationSym))
{
_codeActionCreateInvocations = _codeActionCreateInvocations ?? new Dictionary <INamedTypeSymbol, HashSet <NodeAndSymbol> >();
AddNodeAndSymbol(namedType, invocationContext.Node, invocationSym, _codeActionCreateInvocations);
}
},
GetInvocationKind);
context.RegisterSyntaxNodeAction(objectCreationContext =>
{
var constructor = objectCreationContext.SemanticModel.GetSymbolInfo(objectCreationContext.Node).Symbol as IMethodSymbol;
if (constructor != null && constructor.ContainingType.DerivesFrom(_codeActionSymbol))
{
_codeActionObjectCreations = _codeActionObjectCreations ?? new Dictionary <INamedTypeSymbol, HashSet <NodeAndSymbol> >();
AddNodeAndSymbol(namedType, objectCreationContext.Node, constructor, _codeActionObjectCreations);
}
},
GetObjectCreationKind);
}
protected abstract void GetSyntaxAnalyzer(CodeBlockStartAnalysisContext <TLanguageKindEnum> context, INamedTypeSymbol genericEnumerableSymbol, IMethodSymbol genericEmptyEnumerableSymbol);
protected override void GetSyntaxAnalyzer(CodeBlockStartAnalysisContext <SyntaxKind> context, INamedTypeSymbol genericEnumerableSymbol, IMethodSymbol genericEmptyEnumerableSymbol)
{
context.RegisterSyntaxNodeAction(new SyntaxAnalyzer(genericEnumerableSymbol, genericEmptyEnumerableSymbol).AnalyzeNode, SyntaxKind.ReturnStatement);
}
public static AnalyzerConfigOptions GetAnalyzerConfigOptions <TLanguageKindEnum>(this CodeBlockStartAnalysisContext <TLanguageKindEnum> context)
where TLanguageKindEnum : unmanaged, Enum
{
return(context.Options.AnalyzerConfigOptionsProvider.GetOptions(context.CodeBlock.SyntaxTree));
}
public void CreateAnalyzerWithinCodeBlock(CodeBlockStartAnalysisContext <TLanguageKindEnum> context)
{
GetSyntaxAnalyzer(context, _symbols);
}
#pragma warning disable RS1012 // Start action has no registered actions.
public static SyntaxTree GetSyntaxTree <TLanguageKindEnum>(this CodeBlockStartAnalysisContext <TLanguageKindEnum> context)
#pragma warning restore RS1012 // Start action has no registered actions.
where TLanguageKindEnum : struct =>
context.CodeBlock.SyntaxTree;
public static void OnCodeBlockStarted(CodeBlockStartAnalysisContext<SyntaxKind> context)
{
Action<Action<SyntaxNodeAnalysisContext>, ImmutableArray<SyntaxKind>> registerMethod =
(action, Kinds) => context.RegisterSyntaxNodeAction(action, Kinds);
var analyzer = new NodeAnalyzer();
analyzer.Initialize(registerMethod);
}
protected abstract void GetSyntaxAnalyzer(CodeBlockStartAnalysisContext <TLanguageKindEnum> context, ImmutableHashSet <ISymbol> symbols);
private void CreateAnalyzerWithinCodeBlock(CodeBlockStartAnalysisContext <TLanguageKindEnum> context)
{
var analyzer = GetExecutableNodeAnalyzer();
context.RegisterSyntaxNodeAction(analyzer.AnalyzeNode, analyzer.SyntaxKindsOfInterest.ToArray());
}
public void CreateAnalyzerWithinCodeBlock(CodeBlockStartAnalysisContext<SyntaxKind> context)
{
var blockAnalyzer = new CodeBlockAnalyzer();
context.RegisterCodeBlockEndAction(blockAnalyzer.AnalyzeCodeBlock);
context.RegisterSyntaxNodeAction(blockAnalyzer.AnalyzeNode, blockAnalyzer.SyntaxKindsOfInterest.ToArray());
}
protected override void GetSyntaxAnalyzer(CodeBlockStartAnalysisContext <SyntaxKind> context, ImmutableHashSet <ISymbol> symbols)
{
var analyzer = new SyntaxAnalyzer(symbols);
context.RegisterSyntaxNodeAction(analyzer.AnalyzeNode, analyzer.SyntaxKindsOfInterest.ToArray());
}
protected override void GetCodeBlockEndedAnalyzer(CodeBlockStartAnalysisContext <SyntaxKind> context, IMethodSymbol constructorSymbol)
{
context.RegisterSyntaxNodeAction(new SyntaxNodeAnalyzer(constructorSymbol).AnalyzeNode, SyntaxKind.InvocationExpression);
}
// Actions/CodeBlock
private static void OnCodeBlock_Start(CodeBlockStartAnalysisContext <SyntaxKind> context)
{
context.RegisterCodeBlockEndAction(OnCodeBlock_End);
}
protected abstract void RegisterAnalyzer(CodeBlockStartAnalysisContext <TLanguageKindEnum> context, CompilationSecurityTypes types, Version targetFrameworkVersion);
public void Initialize(CodeBlockStartAnalysisContext <TLanguageKindEnum> context)
{
context.RegisterSyntaxNodeAction(new SyntaxNodeAnalyzer(analyzer, taskTypes).AnalyzeNode, analyzer.AwaitSyntaxKind);
}
public void Initialize(CodeBlockStartAnalysisContext<VisualBasic.SyntaxKind> analysisContext)
{
analysisContext.RegisterCodeBlockEndAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_rule, context.OwningSymbol.Locations.First(), messageArgs: context.OwningSymbol.Name + ":end"));
});
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(s_rule, context.Node.GetLocation(), messageArgs: context.Node.ToFullString()));
},
VisualBasic.SyntaxKind.InvocationExpression);
}
protected abstract void GetCodeBlockEndedAnalyzer(CodeBlockStartAnalysisContext <TLanguageKindEnum> context, IMethodSymbol constructorSymbol);
protected abstract SyntaxNodeAnalyzer GetAnalyzer(CodeBlockStartAnalysisContext <TLanguageKindEnum> context, CompilationSecurityTypes types);
public void Initialize(CodeBlockStartAnalysisContext<CSharp.SyntaxKind> analysisContext)
{
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(Desciptor2, Location.None));
},
CSharp.SyntaxKind.EqualsValueClause);
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(Desciptor3, Location.None));
},
CSharp.SyntaxKind.BaseConstructorInitializer);
analysisContext.RegisterSyntaxNodeAction(
(context) =>
{
DiagnosticDescriptor descriptor;
switch (context.Node.Parent.Kind())
{
case SyntaxKind.PropertyDeclaration:
descriptor = Desciptor4;
break;
case SyntaxKind.IndexerDeclaration:
descriptor = Desciptor5;
break;
default:
descriptor = Desciptor6;
break;
}
context.ReportDiagnostic(CodeAnalysis.Diagnostic.Create(descriptor, Location.None));
},
CSharp.SyntaxKind.ArrowExpressionClause);
}
