/// <summary> /// Get all action symbols and types from the graph extension and its base graph /// </summary> /// <param name="graphExtension">The graph extension to act on</param> /// <param name="pxContext">Context</param> /// <returns/> public static ActionsOverridableCollection GetActionsFromGraphExtensionAndBaseGraph(this ITypeSymbol graphExtension, PXContext pxContext) { graphExtension.ThrowOnNull(nameof(graphExtension)); pxContext.ThrowOnNull(nameof(pxContext)); return(GetActionInfoFromGraphExtension <(ISymbol, INamedTypeSymbol)>(graphExtension, pxContext, AddActionsFromGraph, AddActionsFromGraphExtension)); int AddActionsFromGraph(GraphOverridableItemsCollection <(ISymbol Symbol, INamedTypeSymbol Type)> actionsCollection, ITypeSymbol graph, int startingOrder) { var graphActions = graph.GetActionsFromGraphImpl(pxContext, includeActionsFromInheritanceChain: true); return(actionsCollection.AddRangeWithDeclarationOrder(graphActions, startingOrder, keySelector: action => action.Symbol.Name)); } int AddActionsFromGraphExtension(GraphOverridableItemsCollection <(ISymbol Symbol, INamedTypeSymbol Type)> actionsCollection, ITypeSymbol graphExt, int startingOrder) { var extensionActions = GetActionsFromGraphOrGraphExtensionImpl(graphExt, pxContext); return(actionsCollection.AddRangeWithDeclarationOrder(extensionActions, startingOrder, keySelector: action => action.Symbol.Name)); } }
/// <summary> /// Gets the graph type from graph extension type. /// </summary> /// <param name="graphExtension">The graph extension to act on.</param> /// <param name="pxContext">Context.</param> /// <returns> /// The graph from graph extension. /// </returns> public static ITypeSymbol GetGraphFromGraphExtension(this ITypeSymbol graphExtension, PXContext pxContext) { pxContext.ThrowOnNull(nameof(pxContext)); if (graphExtension == null || !graphExtension.InheritsFrom(pxContext.PXGraphExtensionType)) { return(null); } var baseGraphExtensionType = graphExtension.GetBaseTypesAndThis() .OfType <INamedTypeSymbol>() .FirstOrDefault(type => type.IsGraphExtensionBaseType()); if (baseGraphExtensionType == null) { return(null); } var graphExtTypeArgs = baseGraphExtensionType.TypeArguments; if (graphExtTypeArgs.Length == 0) { return(null); } ITypeSymbol firstTypeArg = graphExtTypeArgs.Last(); return(firstTypeArg.IsPXGraph(pxContext) ? firstTypeArg : null); }
public static bool IsProcessingView(this ITypeSymbol view, PXContext pxContext) { view.ThrowOnNull(nameof(view)); pxContext.ThrowOnNull(nameof(pxContext)); return(view.InheritsFromOrEqualsGeneric(pxContext.PXProcessingBase.Type)); }
/// <summary> /// Get the action handlers symbols and syntax nodes from the graph extension. /// The <paramref name="actionsByName"/> must have <see cref="StringComparer.OrdinalIgnoreCase"/> comparer. /// </summary> /// <param name="graphExtension">The graph extension to act on</param> /// <param name="actionsByName">The actions of the graph dictionary with <see cref="StringComparer.OrdinalIgnoreCase"/> comparer</param> /// <param name="pxContext">Context</param> /// <param name="cancellation">Cancellation token</param> /// <returns></returns> public static ActionHandlersOverridableCollection GetActionHandlersFromGraphExtensionAndBaseGraph(this ITypeSymbol graphExtension, IDictionary <string, ActionInfo> actionsByName, PXContext pxContext, CancellationToken cancellation) { graphExtension.ThrowOnNull(nameof(graphExtension)); actionsByName.ThrowOnNull(nameof(actionsByName)); pxContext.ThrowOnNull(nameof(pxContext)); return(GetActionInfoFromGraphExtension <(MethodDeclarationSyntax, IMethodSymbol)>( graphExtension, pxContext, AddHandlersFromGraph, AddHandlersFromGraphExtension)); int AddHandlersFromGraph(GraphOverridableItemsCollection <(MethodDeclarationSyntax Node, IMethodSymbol Symbol)> handlersCollection, ITypeSymbol graph, int startingOrder) { var graphHandlers = graph.GetActionHandlersFromGraphImpl(actionsByName, pxContext, cancellation, inheritance: true); return(handlersCollection.AddRangeWithDeclarationOrder(graphHandlers, startingOrder, keySelector: h => h.Symbol.Name)); } int AddHandlersFromGraphExtension(GraphOverridableItemsCollection <(MethodDeclarationSyntax Node, IMethodSymbol Symbol)> handlersCollection, ITypeSymbol graphExt, int startingOrder) { var extensionHandlers = graphExt.GetActionHandlersFromGraphOrGraphExtension(actionsByName, pxContext, cancellation); return(handlersCollection.AddRangeWithDeclarationOrder(extensionHandlers, startingOrder, keySelector: h => h.Symbol.Name)); } }
/// <summary> /// Get the view delegates symbols and syntax nodes from the graph extension. /// The <paramref name="viewsByName"/> must have <see cref="StringComparer.OrdinalIgnoreCase"/> comparer. /// </summary> /// <param name="graphExtension">The graph extension to act on</param> /// <param name="viewsByName">The views of the graph extension with <see cref="StringComparer.OrdinalIgnoreCase"/> comparer</param> /// <param name="pxContext">Context</param> /// <param name="cancellation">Cancellation token</param> /// <returns/> public static OverridableItemsCollection <DataViewDelegateInfo> GetViewDelegatesFromGraphExtensionAndBaseGraph(this ITypeSymbol graphExtension, IDictionary <string, DataViewInfo> viewsByName, PXContext pxContext, CancellationToken cancellation) { graphExtension.ThrowOnNull(nameof(graphExtension)); viewsByName.ThrowOnNull(nameof(viewsByName)); pxContext.ThrowOnNull(nameof(pxContext)); return(GetViewInfoFromGraphExtension <DataViewDelegateInfo>(graphExtension, pxContext, AddDelegatesFromGraph, AddDelegatesFromGraphExtension)); int AddDelegatesFromGraph(OverridableItemsCollection <DataViewDelegateInfo> delegates, ITypeSymbol graph, int startingOrder) { var graphViewDelegates = graph.GetRawViewDelegatesFromGraphImpl(viewsByName, pxContext, inheritance: true, cancellation); return(delegates.AddRangeWithDeclarationOrder(graphViewDelegates, startingOrder, (viewDel, order) => new DataViewDelegateInfo(viewDel.Node, viewDel.Symbol, order))); } int AddDelegatesFromGraphExtension(OverridableItemsCollection <DataViewDelegateInfo> delegates, ITypeSymbol graphExt, int startingOrder) { var extensionViewDelegates = graphExt.GetRawViewDelegatesFromGraphOrGraphExtension(viewsByName, pxContext, cancellation); return(delegates.AddRangeWithDeclarationOrder(extensionViewDelegates, startingOrder, (viewDel, order) => new DataViewDelegateInfo(viewDel.Node, viewDel.Symbol, order))); } }
/// <summary> /// Gets the DAC type from DAC extension type. /// </summary> /// <param name="dacExtension">The DAC extension to act on.</param> /// <param name="pxContext">Context.</param> /// <returns> /// The DAC from DAC extension. /// </returns> public static ITypeSymbol GetDacFromDacExtension(this ITypeSymbol dacExtension, PXContext pxContext) { pxContext.ThrowOnNull(nameof(pxContext)); if (dacExtension == null || !dacExtension.IsDacExtension(pxContext)) { return(null); } var baseDacExtensionType = dacExtension.GetBaseTypesAndThis() .OfType <INamedTypeSymbol>() .FirstOrDefault(type => type.IsDacExtensionBaseType()); if (baseDacExtensionType == null) { return(null); } var dacExtTypeArgs = baseDacExtensionType.TypeArguments; if (dacExtTypeArgs.Length == 0) { return(null); } ITypeSymbol dacType = dacExtTypeArgs.Last(); return(dacType.IsDAC(pxContext) ? dacType : null); }
public StartLongOperationDelegateWalker(PXContext pxContext, Compilation compilation, CancellationToken cancellation) : base(compilation, cancellation) { pxContext.ThrowOnNull(nameof(pxContext)); _pxContext = pxContext; }
/// <summary> /// Get the view delegates symbols and syntax nodes from the graph extension. /// The <paramref name="viewsByName"/> must have <see cref="StringComparer.OrdinalIgnoreCase"/> comparer. /// </summary> /// <param name="graphExtension">The graph extension to act on</param> /// <param name="viewsByName">The views of the graph extension with <see cref="StringComparer.OrdinalIgnoreCase"/> comparer</param> /// <param name="pxContext">Context</param> /// <param name="cancellation">Cancellation token</param> /// <returns></returns> public static DataViewDelegatesOverridableCollection GetViewDelegatesFromGraphExtensionAndBaseGraph( this ITypeSymbol graphExtension, IDictionary <string, DataViewInfo> viewsByName, PXContext pxContext, CancellationToken cancellation) { graphExtension.ThrowOnNull(nameof(graphExtension)); viewsByName.ThrowOnNull(nameof(viewsByName)); pxContext.ThrowOnNull(nameof(pxContext)); return(GetViewInfoFromGraphExtension <(MethodDeclarationSyntax, IMethodSymbol)>( graphExtension, pxContext, AddDelegatesFromGraph, AddDelegatesFromGraphExtension)); int AddDelegatesFromGraph(GraphOverridableItemsCollection <(MethodDeclarationSyntax Node, IMethodSymbol Symbol)> delegates, ITypeSymbol graph, int startingOrder) { var graphViewDelegates = graph.GetViewDelegatesFromGraphImpl(viewsByName, pxContext, inheritance: true, cancellation); return(delegates.AddRangeWithDeclarationOrder(graphViewDelegates, startingOrder, keySelector: viewDelegate => viewDelegate.Symbol.Name)); } int AddDelegatesFromGraphExtension(GraphOverridableItemsCollection <(MethodDeclarationSyntax Node, IMethodSymbol Symbol)> delegates, ITypeSymbol graphExt, int startingOrder) { var extensionViewDelegates = graphExt.GetViewDelegatesFromGraphOrGraphExtension(viewsByName, pxContext, cancellation); return(delegates.AddRangeWithDeclarationOrder(extensionViewDelegates, startingOrder, keySelector: viewDelegate => viewDelegate.Symbol.Name)); } }
internal static IEnumerable <(ITypeSymbol GraphSymbol, SyntaxNode GraphNode)> GetDeclaredGraphsAndExtensions( this SyntaxNode root, SemanticModel semanticModel, PXContext context, CancellationToken cancellationToken = default) { root.ThrowOnNull(nameof(root)); context.ThrowOnNull(nameof(context)); semanticModel.ThrowOnNull(nameof(semanticModel)); cancellationToken.ThrowIfCancellationRequested(); return(context.IsPlatformReferenced ? GetDeclaredGraphsAndExtensionsImpl() : Enumerable.Empty <(ITypeSymbol, SyntaxNode)>()); IEnumerable <(ITypeSymbol GraphSymbol, SyntaxNode GraphNode)> GetDeclaredGraphsAndExtensionsImpl() { var declaredClasses = root.DescendantNodesAndSelf().OfType <ClassDeclarationSyntax>(); foreach (ClassDeclarationSyntax classNode in declaredClasses) { ITypeSymbol classTypeSymbol = classNode.GetTypeSymbolFromClassDeclaration(semanticModel, cancellationToken); if (classTypeSymbol != null && classTypeSymbol.IsPXGraphOrExtension(context)) { yield return(classTypeSymbol, classNode); } } } }
/// <summary> /// Get DAC properties from the DAC extension and its base DAC. /// </summary> /// <param name="dacExtension">The DAC extension to act on.</param> /// <param name="pxContext">Context.</param> /// <param name="dacFields">The DAC fields.</param> /// <param name="cancellation">(Optional) Cancellation token.</param> /// <returns> /// The properties from DAC extension and base DAC. /// </returns> public static OverridableItemsCollection <DacPropertyInfo> GetPropertiesFromDacExtensionAndBaseDac(this ITypeSymbol dacExtension, PXContext pxContext, IDictionary <string, DacFieldInfo> dacFields, CancellationToken cancellation = default) { dacExtension.ThrowOnNull(nameof(dacExtension)); pxContext.ThrowOnNull(nameof(pxContext)); var attributeInformation = new AttributeInformation(pxContext); return(GetPropertiesOrFieldsInfoFromDacExtension <DacPropertyInfo>(dacExtension, pxContext, AddPropertiesFromDac, AddPropertiesFromDacExtension)); //-----------------------Local function---------------------------------------- int AddPropertiesFromDac(OverridableItemsCollection <DacPropertyInfo> propertiesCollection, ITypeSymbol dac, int startingOrder) { var rawDacProperties = dac.GetRawPropertiesFromDacImpl(pxContext, includeFromInheritanceChain: true, cancellation); return(propertiesCollection.AddRangeWithDeclarationOrder(rawDacProperties, startingOrder, (dacProperty, order) => DacPropertyInfo.Create(pxContext, dacProperty.Node, dacProperty.Symbol, order, attributeInformation, dacFields))); } int AddPropertiesFromDacExtension(OverridableItemsCollection <DacPropertyInfo> propertiesCollection, ITypeSymbol dacExt, int startingOrder) { var rawDacExtensionProperties = GetRawPropertiesFromDacOrDacExtensionImpl(dacExt, pxContext, cancellation); return(propertiesCollection.AddRangeWithDeclarationOrder(rawDacExtensionProperties, startingOrder, (dacProperty, order) => DacPropertyInfo.Create(pxContext, dacProperty.Node, dacProperty.Symbol, order, attributeInformation, dacFields))); } }
/// <summary> /// Gets the graph extension with base graph extensions from graph extension type. /// </summary> /// <param name="graphExtension">The graph extension to act on.</param> /// <param name="pxContext">Context.</param> /// <param name="sortDirection">The sort direction. The <see cref="SortDirection.Descending"/> order is from the extension to its base extensions/graph. /// The <see cref="SortDirection.Ascending"/> order is from the graph/base extensions to the most derived one.</param> /// <param name="includeGraph">True to include, false to exclude the graph type.</param> /// <returns/> public static IEnumerable <ITypeSymbol> GetGraphExtensionWithBaseExtensions(this ITypeSymbol graphExtension, PXContext pxContext, SortDirection sortDirection, bool includeGraph) { pxContext.ThrowOnNull(nameof(pxContext)); if (graphExtension == null || !graphExtension.InheritsFrom(pxContext.PXGraphExtensionType)) { return(Enumerable.Empty <ITypeSymbol>()); } INamedTypeSymbol extensionBaseType = graphExtension.GetBaseTypesAndThis() .FirstOrDefault(type => type.IsGraphExtensionBaseType()) as INamedTypeSymbol; if (extensionBaseType == null) { return(Enumerable.Empty <ITypeSymbol>()); } var graphType = extensionBaseType.TypeArguments.LastOrDefault(); if (graphType == null || !graphType.IsPXGraph(pxContext)) { return(Enumerable.Empty <ITypeSymbol>()); } return(sortDirection == SortDirection.Ascending ? GetExtensionInAscendingOrder(graphType, graphExtension, extensionBaseType, pxContext, includeGraph) : GetExtensionInDescendingOrder(graphType, graphExtension, extensionBaseType, pxContext, includeGraph)); }
/// <summary> /// Get the DAC field symbols and syntax nodes from the DAC extension. /// </summary> /// <param name="dacExtension">The DAC extension to act on.</param> /// <param name="pxContext">Context.</param> /// <param name="cancellation">Cancellation token.</param> /// <returns> /// The DAC fields from DAC extension and base DAC. /// </returns> public static OverridableItemsCollection <DacFieldInfo> GetDacFieldsFromDacExtensionAndBaseDac(this ITypeSymbol dacExtension, PXContext pxContext, CancellationToken cancellation = default) { dacExtension.ThrowOnNull(nameof(dacExtension)); pxContext.ThrowOnNull(nameof(pxContext)); return(GetPropertiesOrFieldsInfoFromDacExtension <DacFieldInfo>(dacExtension, pxContext, AddFieldsFromDac, AddFieldsFromDacExtension)); int AddFieldsFromDac(OverridableItemsCollection <DacFieldInfo> fieldsCollection, ITypeSymbol dac, int startingOrder) { var rawDacFields = dac.GetRawDacFieldsFromDacImpl(pxContext, includeFromInheritanceChain: true, cancellation); return(fieldsCollection.AddRangeWithDeclarationOrder(rawDacFields, startingOrder, (dacField, order) => new DacFieldInfo(dacField.Node, dacField.Symbol, order))); } int AddFieldsFromDacExtension(OverridableItemsCollection <DacFieldInfo> fieldsCollection, ITypeSymbol dacExt, int startingOrder) { var rawDacExtensionFields = dacExt.GetRawDacFieldsFromDacOrDacExtension(pxContext, cancellation); return(fieldsCollection.AddRangeWithDeclarationOrder(rawDacExtensionFields, startingOrder, (dacField, order) => new DacFieldInfo(dacField.Node, dacField.Symbol, order))); } }
/// <summary> /// Get declared primary DAC from graph or graph extension. /// </summary> /// <param name="graphOrExtension">The graph or graph extension to act on.</param> /// <param name="pxContext">Context.</param> /// <returns> /// The declared primary DAC from graph or graph extension. /// </returns> public static ITypeSymbol GetDeclaredPrimaryDacFromGraphOrGraphExtension(this ITypeSymbol graphOrExtension, PXContext pxContext) { pxContext.ThrowOnNull(nameof(pxContext)); bool isGraph = graphOrExtension?.InheritsFrom(pxContext.PXGraph.Type) ?? false; if (!isGraph && !graphOrExtension?.InheritsFrom(pxContext.PXGraphExtensionType) != true) { return(null); } ITypeSymbol graph = isGraph ? graphOrExtension : graphOrExtension.GetGraphFromGraphExtension(pxContext); var baseGraphType = graph.GetBaseTypesAndThis() .OfType <INamedTypeSymbol>() .FirstOrDefault(type => IsGraphWithPrimaryDacBaseGenericType(type)); if (baseGraphType == null || baseGraphType.TypeArguments.Length < 2) { return(null); } ITypeSymbol primaryDacType = baseGraphType.TypeArguments[1]; return(primaryDacType.IsDAC() ? primaryDacType : null); }
public static PXDBOperationKind GetPXDatabaseSaveOperationKind(IMethodSymbol symbol, PXContext pxContext) { symbol.ThrowOnNull(nameof(symbol)); pxContext.ThrowOnNull(nameof(pxContext)); var containingType = symbol.ContainingType?.OriginalDefinition; if (containingType != null && containingType.InheritsFromOrEquals(pxContext.PXDatabase.Type)) { if (string.Equals(symbol.Name, DelegateNames.Insert)) { return(PXDBOperationKind.Insert); } else if (string.Equals(symbol.Name, DelegateNames.Delete)) { return(PXDBOperationKind.Delete); } else if (string.Equals(symbol.Name, DelegateNames.Update)) { return(PXDBOperationKind.Update); } else if (string.Equals(symbol.Name, DelegateNames.Ensure)) { return(PXDBOperationKind.Ensure); } } return(PXDBOperationKind.None); }
/// <summary> /// Get all action symbols and types from the graph extension and its base graph /// </summary> /// <param name="graphExtension">The graph extension to act on</param> /// <param name="pxContext">Context</param> /// <returns/> public static OverridableItemsCollection <ActionInfo> GetActionsFromGraphExtensionAndBaseGraph(this ITypeSymbol graphExtension, PXContext pxContext) { graphExtension.ThrowOnNull(nameof(graphExtension)); pxContext.ThrowOnNull(nameof(pxContext)); var systemActionsRegister = new PXSystemActions.PXSystemActionsRegister(pxContext); return(GetActionInfoFromGraphExtension <ActionInfo>(graphExtension, pxContext, AddActionsFromGraph, AddActionsFromGraphExtension)); int AddActionsFromGraph(OverridableItemsCollection <ActionInfo> actionsCollection, ITypeSymbol graph, int startingOrder) { var graphActions = graph.GetRawActionsFromGraphImpl(pxContext, includeActionsFromInheritanceChain: true); return(actionsCollection.AddRangeWithDeclarationOrder(graphActions, startingOrder, (action, order) => new ActionInfo(action.ActionSymbol, action.ActionType, order, systemActionsRegister.IsSystemAction(action.ActionType)))); } int AddActionsFromGraphExtension(OverridableItemsCollection <ActionInfo> actionsCollection, ITypeSymbol graphExt, int startingOrder) { var extensionActions = GetRawActionsFromGraphOrGraphExtensionImpl(graphExt, pxContext); return(actionsCollection.AddRangeWithDeclarationOrder(extensionActions, startingOrder, (action, order) => new ActionInfo(action.ActionSymbol, action.ActionType, order, systemActionsRegister.IsSystemAction(action.ActionType)))); } }
/// <summary> /// Gets the DAC extension with base DAC extensions from DAC extension type. /// </summary> /// <param name="dacExtension">The DAC extension to act on.</param> /// <param name="pxContext">Context.</param> /// <param name="sortDirection">The sort direction. The <see cref="SortDirection.Descending"/> order is from the extension to its base extensions/graph. /// The <see cref="SortDirection.Ascending"/> order is from the DAC/base extensions to the most derived one.</param> /// <param name="includeDac">True to include, false to exclude the DAC type.</param> /// <returns/> public static IEnumerable <ITypeSymbol> GetDacExtensionWithBaseExtensions(this ITypeSymbol dacExtension, PXContext pxContext, SortDirection sortDirection, bool includeDac) { pxContext.ThrowOnNull(nameof(pxContext)); if (dacExtension == null || !dacExtension.IsDacExtension(pxContext)) { return(Enumerable.Empty <ITypeSymbol>()); } var extensionBaseType = dacExtension.GetBaseTypesAndThis() .FirstOrDefault(type => type.IsDacExtensionBaseType()) as INamedTypeSymbol; if (extensionBaseType == null) { return(Enumerable.Empty <ITypeSymbol>()); } var dacType = extensionBaseType.TypeArguments.LastOrDefault(); if (dacType == null || !dacType.IsDAC(pxContext)) { return(Enumerable.Empty <ITypeSymbol>()); } return(sortDirection == SortDirection.Ascending ? GetExtensionInAscendingOrder(dacType, dacExtension, extensionBaseType, pxContext, includeDac) : GetExtensionInDescendingOrder(dacType, dacExtension, extensionBaseType, pxContext, includeDac)); }
public PXSystemActionsRegister(PXContext pxContext) { pxContext.ThrowOnNull(nameof(pxContext)); context = pxContext; SystemActions = GetSystemActions(context).ToImmutableHashSet(); }
/// <summary> /// Get the action handlers symbols and syntax nodes from the graph extension. /// The <paramref name="actionsByName"/> must have <see cref="StringComparer.OrdinalIgnoreCase"/> comparer. /// </summary> /// <param name="graphExtension">The graph extension to act on</param> /// <param name="actionsByName">The actions of the graph dictionary with <see cref="StringComparer.OrdinalIgnoreCase"/> comparer</param> /// <param name="pxContext">Context</param> /// <param name="cancellation">Cancellation token</param> /// <returns></returns> public static OverridableItemsCollection <ActionHandlerInfo> GetActionHandlersFromGraphExtensionAndBaseGraph(this ITypeSymbol graphExtension, IDictionary <string, ActionInfo> actionsByName, PXContext pxContext, CancellationToken cancellation) { graphExtension.ThrowOnNull(nameof(graphExtension)); actionsByName.ThrowOnNull(nameof(actionsByName)); pxContext.ThrowOnNull(nameof(pxContext)); return(GetActionInfoFromGraphExtension <ActionHandlerInfo>(graphExtension, pxContext, AddHandlersFromGraph, AddHandlersFromGraphExtension)); int AddHandlersFromGraph(OverridableItemsCollection <ActionHandlerInfo> handlersCollection, ITypeSymbol graph, int startingOrder) { var graphHandlers = graph.GetRawActionHandlersFromGraphImpl(actionsByName, pxContext, cancellation, inheritance: true); return(handlersCollection.AddRangeWithDeclarationOrder(graphHandlers, startingOrder, (hander, order) => new ActionHandlerInfo(hander.Node, hander.Symbol, order))); } int AddHandlersFromGraphExtension(OverridableItemsCollection <ActionHandlerInfo> handlersCollection, ITypeSymbol graphExt, int startingOrder) { var extensionHandlers = graphExt.GetRawActionHandlersFromGraphOrGraphExtension(actionsByName, pxContext, cancellation); return(handlersCollection.AddRangeWithDeclarationOrder(extensionHandlers, startingOrder, (hander, order) => new ActionHandlerInfo(hander.Node, hander.Symbol, order))); } }
/// <summary> /// Determines PXGraph instantiation type for the syntax node (e.g. new PXGraph(), PXGraph.CreateInstance, etc.) /// </summary> public static GraphInstantiationType GetGraphInstantiationType(this SyntaxNode node, SemanticModel semanticModel, PXContext pxContext) { node.ThrowOnNull(nameof(node)); semanticModel.ThrowOnNull(nameof(semanticModel)); pxContext.ThrowOnNull(nameof(pxContext)); // new PXGraph() if (node is ObjectCreationExpressionSyntax objCreationSyntax && objCreationSyntax.Type != null && semanticModel .GetSymbolInfo(objCreationSyntax.Type) .Symbol is ITypeSymbol typeSymbol && typeSymbol.IsPXGraph(pxContext)) { return(typeSymbol.Equals(pxContext.PXGraph.Type) ? GraphInstantiationType.ConstructorOfBaseType : GraphInstantiationType.ConstructorOfSpecificType); } // PXGraph.CreateInstance if (node is InvocationExpressionSyntax invocationSyntax) { var symbolInfo = semanticModel.GetSymbolInfo(invocationSyntax); var methodSymbol = (symbolInfo.Symbol ?? symbolInfo.CandidateSymbols.FirstOrDefault()) as IMethodSymbol; methodSymbol = methodSymbol?.OverriddenMethod?.OriginalDefinition ?? methodSymbol?.OriginalDefinition; if (methodSymbol != null && pxContext.PXGraph.CreateInstance.Contains(methodSymbol)) { return(GraphInstantiationType.CreateInstance); } } return(GraphInstantiationType.None); }
public InstanceCreatedEventsAddHandlerWalker(PXContext pxContext, CancellationToken cancellation) : base(pxContext.Compilation, cancellation, pxContext.CodeAnalysisSettings) { pxContext.ThrowOnNull(nameof(pxContext)); _pxContext = pxContext; }
public VariablesWalker(MethodDeclarationSyntax methodSyntax, SemanticModel semanticModel, PXContext pxContext, CancellationToken cancellationToken) { methodSyntax.ThrowOnNull(nameof(methodSyntax)); semanticModel.ThrowOnNull(nameof(semanticModel)); pxContext.ThrowOnNull(nameof(pxContext)); _semanticModel = semanticModel; _pxContext = pxContext; _cancellationToken = cancellationToken; _eventArgsRowWalker = new EventArgsRowWalker(semanticModel, pxContext); if (methodSyntax.Body != null || methodSyntax.ExpressionBody?.Expression != null) { var dataFlow = methodSyntax.Body != null ? semanticModel.AnalyzeDataFlow(methodSyntax.Body) : semanticModel.AnalyzeDataFlow(methodSyntax.ExpressionBody.Expression); if (dataFlow.Succeeded) { _variables = dataFlow.WrittenInside .Intersect(dataFlow.VariablesDeclared) .OfType <ILocalSymbol>() .ToImmutableHashSet(); } } }
public static PXGraphSemanticModel InferExplicitModel(PXContext pxContext, INamedTypeSymbol typeSymbol, GraphSemanticModelCreationOptions modelCreationOptions, CancellationToken cancellation) { cancellation.ThrowIfCancellationRequested(); pxContext.ThrowOnNull(nameof(pxContext)); typeSymbol.ThrowOnNull(nameof(typeSymbol)); GraphType graphType = GraphType.None; if (typeSymbol.IsPXGraph(pxContext)) { graphType = GraphType.PXGraph; } else if (typeSymbol.IsPXGraphExtension(pxContext)) { graphType = GraphType.PXGraphExtension; } if (graphType != GraphType.None) { return(new PXGraphSemanticModel(pxContext, graphType, typeSymbol, modelCreationOptions, cancellation)); } return(null); }
public PXConnectionScopeVisitor(DiagnosticWalker parent, PXContext pxContext) { parent.ThrowOnNull(nameof(parent)); pxContext.ThrowOnNull(nameof(pxContext)); _parent = parent; _pxContext = pxContext; }
public SavePressWalker(SemanticModel semanticModel, PXContext pxContext) { semanticModel.ThrowOnNull(nameof(semanticModel)); pxContext.ThrowOnNull(nameof(pxContext)); _semanticModel = semanticModel; _pxContext = pxContext; }
protected WalkerBase(SymbolAnalysisContext context, PXContext pxContext) : base(context.Compilation, context.CancellationToken, pxContext.CodeAnalysisSettings) { pxContext.ThrowOnNull(nameof(pxContext)); _context = context; _pxContext = pxContext; }
public BqlGraphArgWalker(SemanticModel semanticModel, PXContext pxContext) { semanticModel.ThrowOnNull(nameof(semanticModel)); pxContext.ThrowOnNull(nameof(pxContext)); _semanticModel = semanticModel; _pxContext = pxContext; }
public EventArgsRowWalker(SemanticModel semanticModel, PXContext pxContext) { semanticModel.ThrowOnNull(nameof(semanticModel)); pxContext.ThrowOnNull(nameof(pxContext)); _semanticModel = semanticModel; _pxContext = pxContext; }
public static bool IsValidViewDelegate(this IMethodSymbol method, PXContext pxContext) { method.ThrowOnNull(nameof(method)); pxContext.ThrowOnNull(nameof(pxContext)); return(method.ReturnType.Equals(pxContext.SystemTypes.IEnumerable) && method.Parameters.All(p => p.RefKind != RefKind.Ref)); }
public GraphSemanticModelForCodeMap(PXGraphEventSemanticModel graphEventSemanticModel, PXContext context) { graphEventSemanticModel.ThrowOnNull(nameof(graphEventSemanticModel)); context.ThrowOnNull(nameof(context)); GraphModel = graphEventSemanticModel; PXOverrides = GetPXOverrides(graphEventSemanticModel.Symbol, context).ToImmutableArray(); }
public Walker(SymbolAnalysisContext context, PXContext pxContext, EventType eventType) : base(context.Compilation, context.CancellationToken) { pxContext.ThrowOnNull(nameof(pxContext)); _context = context; _pxContext = pxContext; _eventType = eventType; }