public override SyntaxNode VisitAttribute(AttributeSyntax node) { AttributeSyntax attributeSyntax = (AttributeSyntax)base.VisitAttribute(node); foreach (var action in _allActions.OfType <AttributeAction>()) { if (action.Key == node.Name.ToString()) { if (action.AttributeActionFunc != null) { var actionExecution = new GenericActionExecution(action, _filePath) { TimesRun = 1 }; try { attributeSyntax = action.AttributeActionFunc(_syntaxGenerator, attributeSyntax); LogHelper.LogInformation(string.Format("{0}: {1}", node.SpanStart, action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allExecutedActions.Add(actionExecution); } } } return(attributeSyntax); }
public override SyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { var symbol = SemanticHelper.GetSemanticSymbol(node, _semanticModel, _preportSemanticModel); ExpressionSyntax newNode = node; bool skipChildren = false; // This is here to skip actions on children node when the main identifier was changed. Just use new expression for the subsequent children actions. foreach (var action in _allActions.OfType <ObjectCreationExpressionAction>()) { if (newNode.ToString() == action.Key || symbol?.OriginalDefinition.ToDisplayString() == action.Key) { var actionExecution = new GenericActionExecution(action, _filePath) { TimesRun = 1 }; try { skipChildren = true; newNode = action.ObjectCreationExpressionGenericActionFunc(_syntaxGenerator, (ObjectCreationExpressionSyntax)newNode); allExecutedActions.Add(actionExecution); LogHelper.LogInformation(string.Format("{0}", action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } } } if (!skipChildren) { newNode = (ObjectCreationExpressionSyntax)base.VisitObjectCreationExpression(node); } return(newNode); }
public override SyntaxNode VisitNamespaceDeclaration(NamespaceDeclarationSyntax node) { NamespaceDeclarationSyntax newNode = (NamespaceDeclarationSyntax)base.VisitNamespaceDeclaration(node); foreach (var action in _allActions.OfType <NamespaceAction>()) { if (action.Key == newNode.Name.ToString()) { var actionExecution = new GenericActionExecution(action, _filePath) { TimesRun = 1 }; try { newNode = action.NamespaceActionFunc(_syntaxGenerator, newNode); LogHelper.LogInformation(string.Format("{0}", action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allExecutedActions.Add(actionExecution); } } return(newNode); }
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node) { var symbol = SemanticHelper.GetSemanticSymbol(node, _semanticModel, _preportSemanticModel); var newNode = base.VisitMemberAccessExpression(node); if (symbol != null) { var nodeKey = $"{symbol.ContainingType}.{node.Name}"; foreach (var action in _allActions.OfType <MemberAccessAction>()) { if (nodeKey == action.Key) { var actionExecution = new GenericActionExecution(action, _filePath) { TimesRun = 1 }; try { newNode = action.MemberAccessActionFunc(_syntaxGenerator, newNode); LogHelper.LogInformation(string.Format("{0}: {1}", node.SpanStart, action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allExecutedActions.Add(actionExecution); } } } return(newNode); }
public override SyntaxNode VisitCompilationUnit(CompilationUnitSyntax node) { CompilationUnitSyntax newNode = (CompilationUnitSyntax)base.VisitCompilationUnit(node); //Applying using actions foreach (var action in _allActions.OfType <UsingAction>()) { var actionExecution = new GenericActionExecution(action, _filePath) { TimesRun = 1 }; try { newNode = action.UsingActionFunc(_syntaxGenerator, newNode); LogHelper.LogInformation(string.Format("{0}", action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allExecutedActions.Add(actionExecution); } return(newNode); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { var symbol = SemanticHelper.GetSemanticSymbol(node, _semanticModel, _preportSemanticModel); var identifierNameSyntax = (IdentifierNameSyntax)base.VisitIdentifierName(node); if (symbol != null) { var nodeKey = symbol.OriginalDefinition != null?symbol.OriginalDefinition.ToString() : symbol.ToString(); foreach (var action in _allActions.OfType <IdentifierNameAction>()) { if (nodeKey == action.Key && identifierNameTypes.Contains(identifierNameSyntax.Parent?.GetType())) { var actionExecution = new GenericActionExecution(action, _filePath) { TimesRun = 1 }; try { identifierNameSyntax = action.IdentifierNameActionFunc(_syntaxGenerator, identifierNameSyntax); LogHelper.LogInformation(string.Format("{0}: {1}", node.SpanStart, action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allExecutedActions.Add(actionExecution); } } } return(identifierNameSyntax); }
public override SyntaxNode VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { ObjectCreationExpressionSyntax newNode = node;// (ObjectCreationExpressionSyntax)base.VisitObjectCreationExpression(node); bool skipChildren = false; foreach (var action in _fileActions.ObjectCreationExpressionActions) { if (newNode.ToString() == action.Key) { var actionExecution = new GenericActionExecution(action, _fileActions.FilePath); actionExecution.TimesRun = 1; try { skipChildren = true; var createdNode = action.ObjectCreationExpressionGenericActionFunc(_syntaxGenerator, newNode); allActions.Add(actionExecution); LogHelper.LogInformation(string.Format("{0}", action.Description)); return(createdNode); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allActions.Add(actionExecution); } } if (!skipChildren) { newNode = (ObjectCreationExpressionSyntax)base.VisitObjectCreationExpression(node); } return(newNode); }
public override SyntaxNode VisitInterfaceDeclaration(InterfaceDeclarationSyntax node) { var classSymbol = SemanticHelper.GetDeclaredSymbol(node, _semanticModel, _preportSemanticModel); InterfaceDeclarationSyntax newNode = (InterfaceDeclarationSyntax)base.VisitInterfaceDeclaration(node); foreach (var action in _allActions.OfType <InterfaceDeclarationAction>()) { if (action.Key == node.Identifier.Text.Trim()) { var actionExecution = new GenericActionExecution(action, _filePath) { TimesRun = 1 }; try { newNode = action.InterfaceDeclarationActionFunc(_syntaxGenerator, newNode); LogHelper.LogInformation(string.Format("{0}: {1}", node.SpanStart, action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allExecutedActions.Add(actionExecution); } } return(newNode); }
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node) { var symbols = _semanticModel.GetSymbolInfo(node); var newNode = (InvocationExpressionSyntax)base.VisitInvocationExpression(node); foreach (var action in _fileActions.InvocationExpressionActions) { if (symbols.Symbol.Name == action.Key) { var actionExecution = new GenericActionExecution(action, _fileActions.FilePath); actionExecution.TimesRun = 1; try { newNode = action.InvocationExpressionActionFunc(_syntaxGenerator, newNode); LogHelper.LogInformation(string.Format("{0}: {1}", node.SpanStart, action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allActions.Add(actionExecution); } } return(newNode); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { var symbolInfo = _semanticModel.GetSymbolInfo(node); var identifierNameSyntax = (IdentifierNameSyntax)base.VisitIdentifierName(node); if (symbolInfo.Symbol != null) { foreach (var action in _fileActions.IdentifierNameActions) { if (symbolInfo.Symbol.ToString() == action.Key && identifierNameTypes.Contains(identifierNameSyntax.Parent?.GetType())) { var actionExecution = new GenericActionExecution(action, _fileActions.FilePath); actionExecution.TimesRun = 1; try { identifierNameSyntax = action.IdentifierNameActionFunc(_syntaxGenerator, identifierNameSyntax); LogHelper.LogInformation(string.Format("{0}: {1}", node.SpanStart, action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allActions.Add(actionExecution); } } } return(identifierNameSyntax); }
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) { var classSymbol = _semanticModel.GetDeclaredSymbol(node); ClassDeclarationSyntax newNode = (ClassDeclarationSyntax)base.VisitClassDeclaration(node); foreach (var action in _fileActions.ClassDeclarationActions) { if (action.Key == node.Identifier.Text.Trim()) { var actionExecution = new GenericActionExecution(action, _fileActions.FilePath); actionExecution.TimesRun = 1; try { newNode = action.ClassDeclarationActionFunc(_syntaxGenerator, newNode); LogHelper.LogInformation(string.Format("{0}: {1}", node.SpanStart, action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allActions.Add(actionExecution); } } return(newNode); }
protected virtual List <GenericActionExecution> ApplyProjectActions(ProjectActions projectActions, ProjectType projectType) { var projectRunActions = new List <GenericActionExecution>(); //Project Level Actions foreach (var projectLevelAction in projectActions.ProjectLevelActions) { var projectActionExecution = new GenericActionExecution(projectLevelAction, _projectConfiguration.ProjectPath) { TimesRun = 1 }; var runResult = string.Empty; if (!_projectConfiguration.IsMockRun) { if (projectLevelAction.ProjectLevelActionFunc != null) { try { runResult = projectLevelAction.ProjectLevelActionFunc(_projectConfiguration.ProjectPath, projectType); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(projectLevelAction.Name, projectLevelAction.Key, ex); projectActionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } } else if (projectLevelAction.ProjectFileActionFunc != null) { try { runResult = projectLevelAction.ProjectFileActionFunc(_projectConfiguration.ProjectPath, projectType, _projectConfiguration.TargetVersions, projectActions.PackageActions.GroupBy(g => g.Name).Select(g => g.FirstOrDefault()).ToDictionary(p => p.Name, p => p.Version), projectActions.ProjectReferenceActions.ToList(), _metadataReferences); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(projectLevelAction.Name, projectLevelAction.Key, ex); projectActionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } } } if (!string.IsNullOrEmpty(runResult)) { projectActionExecution.Description = string.Concat(projectActionExecution.Description, ": ", runResult); projectRunActions.Add(projectActionExecution); LogHelper.LogInformation(projectLevelAction.Description); } } return(projectRunActions); }
public override SyntaxNode VisitExpressionStatement(ExpressionStatementSyntax node) { var newNode = base.VisitExpressionStatement(node); SyntaxNode modifiedNode = newNode; var invocationExpressionNodes = node.DescendantNodes().OfType <InvocationExpressionSyntax>().ToList(); if (invocationExpressionNodes.Count <= 0) { return(newNode); } var invocationExpressionNode = invocationExpressionNodes.First(); var symbol = SemanticHelper.GetSemanticSymbol(invocationExpressionNode, _semanticModel, _preportSemanticModel); if (symbol == null) { return(newNode); } var nodeKey = symbol.OriginalDefinition.ToString(); foreach (var action in _allActions.OfType <ExpressionAction>()) { if (nodeKey == action.Key) { var actionExecution = new GenericActionExecution(action, _filePath) { TimesRun = 1 }; try { modifiedNode = action.ExpressionActionFunc(_syntaxGenerator, newNode); LogHelper.LogInformation(string.Format("{0}: {1}", node.SpanStart, action.Description)); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(action.Name, action.Key, ex); actionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } allExecutedActions.Add(actionExecution); } } return(modifiedNode); }
public Dictionary <string, List <GenericActionExecution> > Run(ProjectActions projectActions, ProjectType projectType) { IEnumerable <FileActions> fileActions = projectActions.FileActions; ConcurrentDictionary <string, List <GenericActionExecution> > actionsPerProject = new ConcurrentDictionary <string, List <GenericActionExecution> >(); var parallelOptions = new ParallelOptions() { MaxDegreeOfParallelism = Constants.ThreadCount }; Parallel.ForEach(_sourceFileBuildResults, parallelOptions, sourceFileBuildResult => { try { var currentFileActions = fileActions.Where(f => f.FilePath == sourceFileBuildResult.SourceFileFullPath).FirstOrDefault(); var root = sourceFileBuildResult.SyntaxTree.GetRoot(); if (currentFileActions != null) { LogHelper.LogInformation("---------------------------------------------------------------------------"); LogHelper.LogInformation("Processing file " + sourceFileBuildResult.SourceFilePath); ActionsRewriter oneRewriter = new ActionsRewriter(sourceFileBuildResult.SemanticModel, sourceFileBuildResult.SyntaxGenerator, currentFileActions); root = oneRewriter.Visit(root); var result = root.NormalizeWhitespace().ToFullString(); //TODO : Can you send a result if (!_projectConfiguration.IsMockRun) { File.WriteAllText(sourceFileBuildResult.SourceFileFullPath, result); } var processedActions = ValidateActions(oneRewriter.allActions, result); processedActions = AddActionsWithoutExecutions(currentFileActions, oneRewriter.allActions); if (!actionsPerProject.TryAdd(sourceFileBuildResult.SourceFileFullPath, processedActions)) { throw new FilePortingException(sourceFileBuildResult.SourceFilePath, new Exception("File already exists in collection")); } } } catch (Exception ex) { var filePortingException = new FilePortingException(sourceFileBuildResult.SourceFilePath, ex); LogHelper.LogError(filePortingException); } }); var projectRunActions = new List <GenericActionExecution>(); //Project Level Actions foreach (var projectLevelAction in projectActions.ProjectLevelActions) { var projectActionExecution = new GenericActionExecution(projectLevelAction, _projectConfiguration.ProjectPath); projectActionExecution.TimesRun = 1; var runResult = string.Empty; if (!_projectConfiguration.IsMockRun) { if (projectLevelAction.ProjectLevelActionFunc != null) { try { runResult = projectLevelAction.ProjectLevelActionFunc(_projectConfiguration.ProjectPath, projectType); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(projectLevelAction.Name, projectLevelAction.Key, ex); projectActionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } } else if (projectLevelAction.ProjectFileActionFunc != null) { try { runResult = projectLevelAction.ProjectFileActionFunc(_projectConfiguration.ProjectPath, projectType, _projectConfiguration.TargetVersions, projectActions.PackageActions.Distinct().ToDictionary(p => p.Name, p => p.Version), projectActions.ProjectReferenceActions.ToList()); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(projectLevelAction.Name, projectLevelAction.Key, ex); projectActionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } } } if (!string.IsNullOrEmpty(runResult)) { projectActionExecution.Description = string.Concat(projectActionExecution.Description, ": ", runResult); projectRunActions.Add(projectActionExecution); LogHelper.LogInformation(projectLevelAction.Description); } } if (!actionsPerProject.TryAdd(Constants.Project, projectRunActions)) { LogHelper.LogError(new FilePortingException(Constants.Project, new Exception("Error adding project to actions collection"))); } return(actionsPerProject.ToDictionary(a => a.Key, a => a.Value)); }