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