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); }