private void WriteSettingsToSharedMemory(CodeAnalysisSettings codeAnalysisSettings) { using MemoryMappedViewStream stream = _memoryMappedFile.CreateViewStream(); using CodeAnalysisSettingsBinaryWriter writer = new CodeAnalysisSettingsBinaryWriter(stream); writer.WriteCodeAnalysisSettings(codeAnalysisSettings); }
public PXContext(Compilation compilation, CodeAnalysisSettings codeAnalysisSettings) { compilation.ThrowOnNull(nameof(compilation)); CodeAnalysisSettings = codeAnalysisSettings ?? CodeAnalysisSettings.Default; Compilation = compilation; IsPlatformReferenced = compilation.GetTypeByMetadataName(TypeFullNames.PXGraph) != null; _bql = new Lazy <BQLSymbols>(() => new BQLSymbols(Compilation)); _bqlTypes = new Lazy <BqlDataTypeSymbols>(() => new BqlDataTypeSymbols(Compilation)); _events = new Lazy <EventSymbols>(() => new EventSymbols(Compilation)); _fieldAttributes = new Lazy <FieldAttributeSymbols>(() => new FieldAttributeSymbols(Compilation)); _systemActionTypes = new Lazy <PXSystemActionSymbols>(() => new PXSystemActionSymbols(Compilation)); _attributes = new Lazy <AttributeSymbols>(() => new AttributeSymbols(Compilation)); _systemTypes = new Lazy <SystemTypeSymbols>(() => new SystemTypeSymbols(Compilation)); _localizationMethods = new Lazy <LocalizationSymbols>(() => new LocalizationSymbols(Compilation)); _pxGraph = new Lazy <PXGraphSymbols>(() => new PXGraphSymbols(Compilation)); _pxCache = new Lazy <PXCacheSymbols>(() => new PXCacheSymbols(Compilation)); _pxAction = new Lazy <PXActionSymbols>(() => new PXActionSymbols(Compilation)); _pxDatabase = new Lazy <PXDatabaseSymbols>(() => new PXDatabaseSymbols(Compilation)); _pxView = new Lazy <PXViewSymbols>(() => new PXViewSymbols(Compilation)); _exceptions = new Lazy <ExceptionSymbols>(() => new ExceptionSymbols(Compilation)); _pxSelectBaseGeneric = new Lazy <PXSelectBaseGenericSymbols>(() => new PXSelectBaseGenericSymbols(Compilation)); _pxSelectBase = new Lazy <PXSelectBaseSymbols>(() => new PXSelectBaseSymbols(Compilation)); _pxSelectExtensionSymbols = new Lazy <PXSelectExtensionSymbols>(() => new PXSelectExtensionSymbols(Compilation)); _pxProcessingBase = new Lazy <PXProcessingBaseSymbols>(() => new PXProcessingBaseSymbols(Compilation)); _referentialIntegritySymbols = new Lazy <PXReferentialIntegritySymbols>(() => new PXReferentialIntegritySymbols(Compilation)); _uiPresentationLogicMethods = new Lazy <ImmutableHashSet <IMethodSymbol> >(GetUiPresentationLogicMethods); IsAcumatica2018R2 = PXSelectBase2018R2NewType != null; IsAcumatica2019R1 = IImplementType != null; }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { context.CancellationToken.ThrowIfCancellationRequested(); if (!pxGraph.IsProcessing) { return; } var processingViews = pxGraph.Views.Where(v => v.IsProcessing); var walker = new Walker(context, pxContext); foreach (var view in processingViews) { foreach (var d in view.ParametersDelegates) { walker.Visit(d.Node); } foreach (var d in view.ProcessDelegates) { walker.Visit(d.Node); } foreach (var d in view.FinallyProcessDelegates) { walker.Visit(d.Node); } } }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings codeAnalysisSettings, EventType eventType) { context.CancellationToken.ThrowIfCancellationRequested(); if (AnalyzedEventTypes.TryGetValue(eventType, out RowChangesAnalysisMode analysisMode)) { var methodSymbol = (IMethodSymbol)context.Symbol; var methodSyntax = methodSymbol.GetSyntax(context.CancellationToken) as MethodDeclarationSyntax; if (methodSyntax != null) { var semanticModel = context.Compilation.GetSemanticModel(methodSyntax.SyntaxTree, true); // Find all variables that are declared and assigned with e.Row inside the analyzed method var variablesWalker = new VariablesWalker(methodSyntax, semanticModel, pxContext, context.CancellationToken); methodSyntax.Accept(variablesWalker); // Perform analysis var diagnosticWalker = new DiagnosticWalker(context, semanticModel, pxContext, variablesWalker.Result, analysisMode, eventType); methodSyntax.Accept(diagnosticWalker); } } }
public XmlCommentsWalker(SyntaxNodeAnalysisContext syntaxContext, PXContext pxContext, CodeAnalysisSettings codeAnalysisSettings) { _syntaxContext = syntaxContext; _pxContext = pxContext; _codeAnalysisSettings = codeAnalysisSettings; }
public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { context.CancellationToken.ThrowIfCancellationRequested(); AcuminatorVsixPackageLoader.EnsurePackageLoaded(); if (!_settingsProvidedExternally) { CodeAnalysisSettings = AnalyzersOutOfProcessSettingsProvider.GetCodeAnalysisSettings(); //Initialize settings from global values after potential package load } if (!CodeAnalysisSettings.StaticAnalysisEnabled) { return; } SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false); if (semanticModel?.Compilation == null) { return; } var pxContext = new PXContext(semanticModel.Compilation, CodeAnalysisSettings); if (ShouldAnalyze(semanticModel, pxContext)) { await ComputeRefactoringsAsync(context, semanticModel, pxContext).ConfigureAwait(false); } }
public static void ReportDiagnosticWithSuppressionCheck(this SymbolAnalysisContext context, Diagnostic diagnostic, CodeAnalysisSettings settings) { var semanticModel = context.Compilation.GetSemanticModel(diagnostic.Location.SourceTree); SuppressionManager.ReportDiagnosticWithSuppressionCheck( semanticModel, context.ReportDiagnostic, diagnostic, settings, context.CancellationToken); }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { context.CancellationToken.ThrowIfCancellationRequested(); var walker = new Walker(context, pxContext); CheckProcessingDelegates(pxGraph, walker, context.CancellationToken); CheckLongOperationStartDelegates(pxGraph.Symbol, walker, pxContext, context.Compilation, context.CancellationToken); }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings codeAnalysisSettings, EventType eventType) { context.CancellationToken.ThrowIfCancellationRequested(); var methodSymbol = (IMethodSymbol)context.Symbol; var methodSyntax = methodSymbol.GetSyntax(context.CancellationToken) as CSharpSyntaxNode; methodSyntax?.Accept(new Walker(context, pxContext, eventType)); }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { Walker walker = new Walker(context, pxContext, Descriptors.PX1059_ChangesInPXCacheDuringPXGraphInitialization); foreach (GraphInitializerInfo initializer in pxGraph.Initializers) { context.CancellationToken.ThrowIfCancellationRequested(); walker.Visit(initializer.Node); } }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings codeAnalysisSettings, EventType eventType) { context.CancellationToken.ThrowIfCancellationRequested(); var methodSymbol = (IMethodSymbol)context.Symbol; var methodSyntax = methodSymbol.GetSyntax(context.CancellationToken) as CSharpSyntaxNode; var walker = new StartLongOperationWalker(context, pxContext, Descriptors.PX1046_LongOperationInEventHandlers); methodSyntax?.Accept(walker); }
public OutOfProcessSettingsUpdater(ISettingsEvents settingsEvents, CodeAnalysisSettings initialSettings) { initialSettings.ThrowOnNull(nameof(initialSettings)); _settingsEvents = settingsEvents.CheckIfNull(nameof(settingsEvents)); _memoryMappedFile = CreateOrOpenMemoryMappedFile(); WriteSettingsToSharedMemory(initialSettings); _settingsEvents.CodeAnalysisSettingChanged += SettingsEvents_CodeAnalysisSettingChanged; }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { context.CancellationToken.ThrowIfCancellationRequested(); StartLongOperationWalker walker = new StartLongOperationWalker(context, pxContext, Descriptors.PX1054_PXGraphLongRunOperationDuringInitialization); foreach (GraphInitializerInfo initializer in pxGraph.Initializers) { context.CancellationToken.ThrowIfCancellationRequested(); walker.Visit(initializer.Node); } }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings codeAnalysisSettings, EventType eventType) { context.CancellationToken.ThrowIfCancellationRequested(); if (codeAnalysisSettings.IsvSpecificAnalyzersEnabled && eventType == EventType.RowSelected) { var methodSymbol = (IMethodSymbol)context.Symbol; var methodSyntax = methodSymbol.GetSyntax(context.CancellationToken) as CSharpSyntaxNode; methodSyntax?.Accept(new Walker(context, pxContext, Descriptors.PX1049_DatabaseQueriesInRowSelected)); } }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { context.CancellationToken.ThrowIfCancellationRequested(); StartLongOperationWalker walker = new StartLongOperationWalker(context, pxContext, Descriptors.PX1080_DataViewDelegateLongOperationStart); foreach (DataViewDelegateInfo del in pxGraph.ViewDelegates) { context.CancellationToken.ThrowIfCancellationRequested(); walker.Visit(del.Node); } }
private static async Task GenerateWrapperImplementations() { string baseDirectory = Path.GetFullPath( Path.Combine(Path.GetDirectoryName(typeof(Program).Assembly.Location), @"..\..\..\..")); SolutionWithCodeAnalysis solution = await SolutionWithCodeAnalysis.OpenAsync( Path.Combine(baseDirectory, @"CSharpDom.sln")); ProjectWithCodeAnalysis project = solution.Projects.First(p => p.Syntax.Name == "CSharpDom"); project.Lock(); foreach (DocumentWithCodeAnalysis document in project.Documents .Where(document => document.FullFilePath.Contains(@"CSharpDom\Wrappers\Internal")) .OrderBy(document => document.FullFilePath)) { document.IsLocked = true; bool isEdited = false; LoadedDocumentWithCodeAnalysis loadedDocument = await document.LoadAsync(); using (CodeAnalysisSettings.AllowEdits(loadedDocument)) { SealedClassWithCodeAnalysis @class = loadedDocument.Namespaces.First().Classes.SealedClasses.FirstOrDefault(); if (@class == null) { continue; } foreach (SealedClassPropertyWithCodeAnalysis property in @class.Properties .Where(property => property.GetAccessor.Body.Statements.FirstOrDefault() is ThrowStatementWithCodeAnalysis) .ToArray()) { isEdited = true; string propertyName = property.Name; string fieldName = propertyName.Substring(0, 1).ToLower() + propertyName.Substring(1); SealedClassFieldWithCodeAnalysis field = new SealedClassFieldWithCodeAnalysis( ClassMemberVisibilityModifier.Private, new DelegateReferenceWithCodeAnalysis("Func", property.PropertyType), fieldName); @class.Fields.Fields.Add(field); IList <IStatementWithCodeAnalysis> statements = property.GetAccessor.Body.Statements; statements.Clear(); statements.Add( StatementFactory.Return(ExpressionFactory.MethodCall(ExpressionFactory.Identifier(fieldName)))); } } if (isEdited) { string sourceCode = loadedDocument.ToSourceCode(); File.WriteAllText(document.FullFilePath, sourceCode); } } }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { context.CancellationToken.ThrowIfCancellationRequested(); var walker = new Walker(context, pxContext, Descriptors.PX1089_UiPresentationLogicInActionDelegates); var delegateNodes = pxGraph.ActionHandlers .Where(h => h.Node != null) .Select(h => h.Node); foreach (var node in delegateNodes) { walker.Visit(node); } }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings codeAnalysisSettings, EventType eventType) { context.CancellationToken.ThrowIfCancellationRequested(); if (eventType != EventType.RowSelected && eventType != EventType.CacheAttached) { var methodSymbol = (IMethodSymbol)context.Symbol; var methodSyntax = methodSymbol.GetSyntax(context.CancellationToken) as CSharpSyntaxNode; var walker = new Walker(context, pxContext, Descriptors.PX1070_UiPresentationLogicInEventHandlers); methodSyntax?.Accept(walker); } }
public void WriteCodeAnalysisSettings(CodeAnalysisSettings codeAnalysisSettings) { codeAnalysisSettings.ThrowOnNull(nameof(codeAnalysisSettings)); if (_isDisposed) { throw new ObjectDisposedException(objectName: nameof(CodeAnalysisSettingsBinaryWriter)); } _writer.Write(codeAnalysisSettings.RecursiveAnalysisEnabled); _writer.Write(codeAnalysisSettings.IsvSpecificAnalyzersEnabled); _writer.Write(codeAnalysisSettings.StaticAnalysisEnabled); _writer.Write(codeAnalysisSettings.SuppressionMechanismEnabled); _writer.Write(codeAnalysisSettings.PX1007DocumentationDiagnosticEnabled); }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { if (!settings.IsvSpecificAnalyzersEnabled) { return; } var dbQueriesWalker = new Walker(context, pxContext, Descriptors.PX1085_DatabaseQueriesInPXGraphInitialization); foreach (var initializer in pxGraph.Initializers) { context.CancellationToken.ThrowIfCancellationRequested(); dbQueriesWalker.Visit(initializer.Node); } }
public static async Task GenerateEditableInterface(DocumentWithCodeAnalysis document) { string filePath = document.FullFilePath; string destinationPath = Path.Combine( Path.GetDirectoryName(filePath).Replace(@"CSharpDom\Common", @"CSharpDom\Common\Editable"), GetNewName(Path.GetFileName(filePath))); if (File.Exists(destinationPath)) { return; } LoadedDocumentWithCodeAnalysis loadedDocument = await document.LoadAsync(); NamespaceWithCodeAnalysis @namespace = loadedDocument.Namespaces.First(); if (@namespace.Interfaces.Count == 0) { return; } Console.WriteLine($"Writing: {Path.GetFileName(destinationPath)}"); string namespaceName = @namespace.Name; using (CodeAnalysisSettings.AllowEdits(loadedDocument)) { EditUsingDirectives(loadedDocument, namespaceName); @namespace.Name = Regex.Replace(namespaceName, "^CSharpDom.Common", "CSharpDom.Common.Editable"); InterfaceWithCodeAnalysis @interface = @namespace.Interfaces.First(); string interfaceName = @interface.Name; @interface.Name = GetNewName(interfaceName); List <ITypeReferenceWithCodeAnalysis> genericParameters = EditInterfaceGenericParameters(@interface); EditInterfaceBaseInterfaces(@interface, interfaceName, genericParameters); EditInterfaceProperties(@interface); } Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)); const int maximumLineLength = 120; string sourceCode = loadedDocument.ToSourceCode( new IndentBaseTypeListIfTooLongRule(maximumLineLength), new IndentGenericParamterDefinitionsIfTooLongRule(maximumLineLength), new IndentMethodParametersIfTooLongRule(maximumLineLength)); File.WriteAllText(destinationPath, sourceCode); }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings codeAnalysisSettings, EventType eventType) { context.CancellationToken.ThrowIfCancellationRequested(); if (eventType != EventType.None) { var methodSymbol = (IMethodSymbol)context.Symbol; var methodSyntax = methodSymbol.GetSyntax(context.CancellationToken) as CSharpSyntaxNode; if (methodSyntax != null) { var walker = new Walker(context, pxContext, eventType); methodSyntax.Accept(walker); } } }
public void CheckCodeAnalysisSettingsSerialization(bool recursiveAnalysisEnabled, bool isvSpecificAnalyzersEnabled, bool staticAnalysisEnabled, bool suppressionMechanismEnabled, bool px1007DocumentationDiagnosticEnabled) { var expectedSettings = new CodeAnalysisSettings(recursiveAnalysisEnabled, isvSpecificAnalyzersEnabled, staticAnalysisEnabled, suppressionMechanismEnabled, px1007DocumentationDiagnosticEnabled); using var stream = new MemoryStream(capacity: sizeof(bool) * 5 + 20); using var writer = new CodeAnalysisSettingsBinaryWriter(stream); writer.WriteCodeAnalysisSettings(expectedSettings); stream.Position = 0; using var reader = new CodeAnalysisSettingsBinaryReader(stream); var deserializedSettings = reader.ReadCodeAnalysisSettings(); Assert.Equal(deserializedSettings, expectedSettings); }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings codeAnalysisSettings, EventType eventType) { context.CancellationToken.ThrowIfCancellationRequested(); var eventSet = codeAnalysisSettings.IsvSpecificAnalyzersEnabled ? AnalyzedEventTypesForIsv : AnalyzedEventTypes; if (eventSet.Contains(eventType)) { var methodSymbol = (IMethodSymbol)context.Symbol; var methodSyntax = methodSymbol.GetSyntax(context.CancellationToken) as CSharpSyntaxNode; var walker = new Walker(context, pxContext, Descriptors.PX1044_ChangesInPXCacheInEventHandlers, eventType); methodSyntax?.Accept(walker); } }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { context.CancellationToken.ThrowIfCancellationRequested(); PXGraphCreateInstanceWalker walker = new PXGraphCreateInstanceWalker(context, pxContext, Descriptors.PX1057_PXGraphCreationDuringInitialization); foreach (GraphInitializerInfo initializer in pxGraph.Initializers) { context.CancellationToken.ThrowIfCancellationRequested(); walker.Visit(initializer.Node); } walker = new PXGraphCreateInstanceWalker(context, pxContext, Descriptors.PX1084_GraphCreationInDataViewDelegate); foreach (DataViewDelegateInfo del in pxGraph.ViewDelegates) { context.CancellationToken.ThrowIfCancellationRequested(); walker.Visit(del.Node); } }
private CodeAnalysisSettings GetCodeAnalysisSettings() { if (_settings != null) { return(_settings); // for unit tests } CodeAnalysisSettings settings = null; try { if (ServiceLocator.IsLocationProviderSet) { settings = ServiceLocator.Current.GetInstance <CodeAnalysisSettings>(); } } catch { // TODO: log the exception } return(settings ?? CodeAnalysisSettings.Default); }
public static CodeAnalysisSettings GetCodeAnalysisSettings() { if (SharedVsSettings.IsInsideVsProcess) { return(GlobalCodeAnalysisSettings.Instance); } if (!_isSharedMemoryOpened) { lock (_lock) { if (!_isSharedMemoryOpened) { _memoryMappedFile = OpenExistingMemoryMappedFile(); _isSharedMemoryOpened = _memoryMappedFile != null; } } } if (_memoryMappedFile == null) { return(GlobalCodeAnalysisSettings.Instance); } try { using MemoryMappedViewStream stream = _memoryMappedFile.CreateViewStream(); using var reader = new CodeAnalysisSettingsBinaryReader(stream); CodeAnalysisSettings codeAnalysisSettings = reader.ReadCodeAnalysisSettings(); return(codeAnalysisSettings); } catch (Exception) { return(GlobalCodeAnalysisSettings.Instance); } }
public void Analyze(SymbolAnalysisContext context, PXContext pxContext, CodeAnalysisSettings settings, PXGraphSemanticModel pxGraph) { context.CancellationToken.ThrowIfCancellationRequested(); var ownDelegatesDictionary = pxGraph.ViewDelegates .Where(d => pxGraph.Symbol.Equals(d.Symbol.ContainingType)) .ToDictionary(d => d.Symbol.Name, d => d, StringComparer.OrdinalIgnoreCase); var ownRelatedViewsHashSet = pxGraph.Views .Where(v => ownDelegatesDictionary.ContainsKey(v.Symbol.Name) && pxGraph.Symbol.Equals(v.Symbol.ContainingType)) .Select(v => v.Symbol.Name) .ToImmutableHashSet(StringComparer.OrdinalIgnoreCase); var baseNonRedeclaredRelatedViewsBuilder = ImmutableHashSet <ISymbol> .Empty.ToBuilder(); foreach (var view in pxGraph.Views) { for (var curView = view; curView != null; curView = curView.Base) { if (ownDelegatesDictionary.ContainsKey(curView.Symbol.Name) && !pxGraph.Symbol.Equals(curView.Symbol.ContainingType) && !ownRelatedViewsHashSet.Contains(curView.Symbol.Name)) { baseNonRedeclaredRelatedViewsBuilder.Add(curView.Symbol); } } } var baseNonRedeclaredRelatedViewsHashSet = baseNonRedeclaredRelatedViewsBuilder.ToImmutable(); foreach (var viewDelegate in ownDelegatesDictionary.Values) { var walker = new Walker(context, pxContext, baseNonRedeclaredRelatedViewsHashSet); walker.Visit(viewDelegate.Node); } }
/// <summary> /// Constructor. /// </summary> /// <param name="codeAnalysisSettings">(Optional) The code analysis settings for unit tests.</param> protected PXCodeRefactoringProvider(CodeAnalysisSettings codeAnalysisSettings = null) { CodeAnalysisSettings = codeAnalysisSettings; _settingsProvidedExternally = codeAnalysisSettings != null; }
/// <summary> /// Constructor for the unit tests. /// </summary> public DacAnalyzersAggregator(CodeAnalysisSettings settings, params IDacAnalyzer[] innerAnalyzers) : base(settings, innerAnalyzers) { }