public static bool ResolveReturnInBody(EmbeddedStatement body) { if (body.GetChildsByType(typeof(ReturnStatement)).Length != 0) { return(true); } MethodDeclaration method = (MethodDeclaration)body.GetParentByType(typeof(MethodDeclaration)); SyntaxTreeNode[] ifConstructions = body.GetChildsByType(typeof(IfStatement), false, false); if (body.Childs.Count == 0 || ifConstructions.Length == 0) { ReportError(new NotAllCodePathsReturnsValues(method.SourceContext)); return(false); } foreach (IfStatement ifConstruction in ifConstructions) { if (ifConstruction.ElseBody == null && !(ResolveReturnInBody((EmbeddedStatement)ifConstruction.Body) && ResolveReturnInBody((EmbeddedStatement)ifConstruction.ElseBody))) { return(false); } } return(true); }
private static BlockSyntax GetBlockThatCanBeEmbeddedStatement(SyntaxNode node) { StatementSyntax childStatement = EmbeddedStatement.GetBlockOrEmbeddedStatement(node); if (childStatement?.IsKind(SyntaxKind.Block) == true) { var block = (BlockSyntax)childStatement; SyntaxList <StatementSyntax> statements = block.Statements; if (statements.Count == 1) { StatementSyntax statement = statements[0]; if (!statement.IsKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.LabeledStatement) && statement.IsSingleLine() && EmbeddedStatement.FormattingSupportsEmbeddedStatement(node)) { return(block); } } } return(null); }
public static void ResolveEmbeddedStatement(EmbeddedStatement body, Table.Table table) { Table.Table bodyTable = Table.Table.CreateTable(table); foreach (SyntaxTreeNode statement in body.Childs) { ResolveStatement((Statement)statement, bodyTable); } }
private static void AnalyzeEmbeddedStatement(SyntaxNodeAnalysisContext context, SyntaxToken token, StatementSyntax statement) { if (statement != null && EmbeddedStatement.IsEmbeddedStatement(statement)) { Analyze(context, token, statement); } }
public static async Task <Document> RefactorAsync( Document document, ReturnStatementSyntax returnStatement, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); SyntaxToken returnKeyword = returnStatement.ReturnKeyword; ExpressionSyntax expression = returnStatement.Expression; switch (GetReplacementKind(returnStatement, null, semanticModel, cancellationToken)) { case SyntaxKind.YieldReturnStatement: { YieldStatementSyntax yieldReturnStatement = YieldStatement( SyntaxKind.YieldReturnStatement, Token(returnKeyword.LeadingTrivia, SyntaxKind.YieldKeyword, TriviaList(Space)), returnKeyword.WithoutLeadingTrivia(), expression, returnStatement.SemicolonToken); return(await document.ReplaceNodeAsync(returnStatement, yieldReturnStatement, cancellationToken).ConfigureAwait(false)); } case SyntaxKind.ForEachStatement: { string identifier = Identifier.EnsureUniqueLocalName("item", returnStatement.SpanStart, semanticModel, cancellationToken); YieldStatementSyntax yieldReturnStatement = YieldStatement( SyntaxKind.YieldReturnStatement, Token(default(SyntaxTriviaList), SyntaxKind.YieldKeyword, TriviaList(Space)), returnKeyword.WithoutLeadingTrivia(), IdentifierName(identifier), returnStatement.SemicolonToken.WithoutTrailingTrivia()); StatementSyntax newNode = ForEachStatement( VarType(), identifier, expression, Block(yieldReturnStatement)); if (EmbeddedStatement.IsEmbeddedStatement(returnStatement)) { newNode = Block(newNode); } newNode = newNode.WithTriviaFrom(returnStatement); return(await document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken).ConfigureAwait(false)); } default: { Debug.Assert(false, ""); return(document); } } }
public static void ResolveIdentifierExpressions(SyntaxTreeNode inNode, Table.Table table) { EmbeddedStatement body = (EmbeddedStatement)inNode.GetParentByType(typeof(EmbeddedStatement)); foreach (IdentifierExpression identifier in inNode.GetChildsByType(typeof(IdentifierExpression), true)) { ResolveIdentifierExpression(identifier, table, body); } }
public void InitializeInBlock(IdentifierExpression identifierExpression, EmbeddedStatement block) { TableIdentifier identifier = FetchIdentifier(identifierExpression.Name); if (identifier != null) { identifier.InitializedBlocks.Add(block); } }
public static void Analyze(SyntaxNodeAnalysisContext context, SyntaxNode emptyStatement) { SyntaxNode parent = emptyStatement.Parent; if (parent != null && !EmbeddedStatement.CanContainEmbeddedStatement(parent)) { context.ReportDiagnostic(DiagnosticDescriptors.RemoveEmptyStatement, emptyStatement); } }
public bool IsInitializedInBlock(IdentifierExpression identifierExpression, EmbeddedStatement block) { for (SyntaxTreeNode thisBlock = block; thisBlock != null; thisBlock = thisBlock.GetParentByType(typeof(EmbeddedStatement))) { if (this.FetchIdentifier(identifierExpression.Name).InitializedBlocks.Contains((EmbeddedStatement)thisBlock)) { return(true); } } return(false); }
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxNode node) { StatementSyntax statement = EmbeddedStatement.GetEmbeddedStatement(node); if (statement != null) { context.ReportDiagnostic( DiagnosticDescriptors.AvoidEmbeddedStatementInIfElse, statement, node.GetTitle()); } }
private void AnalyzeStatement(SyntaxNodeAnalysisContext context) { StatementSyntax statement = EmbeddedStatement.GetEmbeddedStatement(context.Node); if (statement != null) { context.ReportDiagnostic( DiagnosticDescriptors.AvoidEmbeddedStatement, statement, GetName(context.Node)); } }
private static bool CanRefactor(RefactoringContext context, BlockSyntax block) { if (context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(block) && EmbeddedStatement.IsEmbeddableBlock(block)) { StatementSyntax statement = EmbeddedStatement.GetEmbeddedStatement(block.Statements[0]); return(statement == null || !statement.FullSpan.Contains(context.Span)); } return(false); }
private static void EmitEmbeddedStatement(EmbeddedStatement body, ILGenerator methodIL) { foreach (Statement statement in body.Childs) { EmitStatement(statement, methodIL); } if (body.Parent is MethodDeclaration) { if (((MethodDeclaration)body.Parent).ReturnType.GetEquivalence() == typeof(void)) { methodIL.Emit(OpCodes.Ret); } } }
private static StatementSyntax GetEmbeddedStatementThatShouldBeInsideBlock(SyntaxNode node) { StatementSyntax statement = EmbeddedStatement.GetBlockOrEmbeddedStatement(node); if (statement?.IsKind(SyntaxKind.Block) == false) { if (!statement.IsSingleLine() || !EmbeddedStatement.FormattingSupportsEmbeddedStatement(node)) { return(statement); } } return(null); }
private static async Task <Document> RefactorAsync( Document document, ExpressionSyntax expression, StatementSyntax statement, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); if (EmbeddedStatement.IsEmbeddedStatement(statement)) { return(await document.ReplaceNodeAsync(statement, Block(statement, CreateNullCheck(expression)), cancellationToken).ConfigureAwait(false)); } else { StatementContainer container; if (StatementContainer.TryCreate(statement, out container)) { SyntaxList <StatementSyntax> statements = container.Statements; int statementIndex = statements.IndexOf(statement); ISymbol symbol = (statement.IsKind(SyntaxKind.LocalDeclarationStatement)) ? semanticModel.GetDeclaredSymbol(((LocalDeclarationStatementSyntax)statement).Declaration.Variables.First(), cancellationToken) : semanticModel.GetSymbol(expression, cancellationToken); int lastStatementIndex = IncludeAllReferencesOfSymbol(symbol, expression.Kind(), statements, statementIndex + 1, semanticModel, cancellationToken); if (lastStatementIndex != -1) { if (lastStatementIndex < statements.Count - 1) { lastStatementIndex = IncludeAllReferencesOfVariablesDeclared(statements, statementIndex + 1, lastStatementIndex, semanticModel, cancellationToken); } return(await RefactorAsync( document, expression, statements, container, statementIndex, lastStatementIndex, cancellationToken).ConfigureAwait(false)); } } } return(await document.InsertNodeAfterAsync(statement, CreateNullCheck(expression), cancellationToken).ConfigureAwait(false)); }
private static bool NullCheckExists(ExpressionSyntax expression, StatementSyntax statement) { if (!EmbeddedStatement.IsEmbeddedStatement(statement)) { StatementContainer container; if (StatementContainer.TryCreate(statement, out container)) { SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(statement); if (index < statements.Count - 1) { StatementSyntax nextStatement = statements[index + 1]; if (nextStatement.IsKind(SyntaxKind.IfStatement)) { var ifStatement = (IfStatementSyntax)nextStatement; ExpressionSyntax condition = ifStatement.Condition; if (condition?.IsKind(SyntaxKind.NotEqualsExpression) == true) { var notEqualsExpression = (BinaryExpressionSyntax)condition; ExpressionSyntax left = notEqualsExpression.Left; if (left?.IsEquivalentTo(expression, topLevel: false) == true) { ExpressionSyntax right = notEqualsExpression.Right; if (right?.IsKind(SyntaxKind.NullLiteralExpression) == true) { return(true); } } } } } } } return(false); }
private static BlockSyntax GetBlockThatCanBeEmbeddedStatement(SyntaxNode node) { StatementSyntax childStatement = EmbeddedStatement.GetBlockOrEmbeddedStatement(node); if (childStatement?.IsKind(SyntaxKind.Block) == true) { var block = (BlockSyntax)childStatement; StatementSyntax statement = block.SingleStatementOrDefault(); if (statement?.IsKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.LabeledStatement) == false && statement.IsSingleLine() && EmbeddedStatement.FormattingSupportsEmbeddedStatement(node)) { return(block); } } return(null); }
public static void ResolveAdressor(Expression adressor, EmbeddedStatement body, Table.Table table) { if (adressor is IdentifierExpression) { ResolveIdentifierExpression((IdentifierExpression)adressor, table, body, false); TableIdentifier tableIdentifier = table.FetchIdentifier(((IdentifierExpression)adressor).Name); if (tableIdentifier != null && tableIdentifier.IsGlobal) { tableIdentifier.InitializedGlobally = true; } else { table.InitializeInBlock((IdentifierExpression)adressor, body); } } else { ResolveArrayElement((ArrayElementExpression)adressor, table, true); } }
private static bool CanRefactorIfElse(BlockSyntax selectedBlock, IfStatementSyntax topmostIf) { bool success = false; foreach (BlockSyntax block in GetBlocks(topmostIf)) { if (block == selectedBlock) { continue; } else if (EmbeddedStatement.IsEmbeddableBlock(block)) { success = true; } else { return(false); } } return(success); }
public static void ResolveAssignmentStatement(AssignmentStatement assignment, Table.Table table) { EmbeddedStatement body = (EmbeddedStatement)assignment.GetParentByType(typeof(EmbeddedStatement)); ResolveExpression(assignment.AdressableExpression, table); if (assignment.AdressorExpressions.Length > 1) { foreach (IdentifierExpression identifier in assignment.AdressorExpressions) { ResolveIdentifierExpression(identifier, table, body); TableIdentifier tableIdentifier = table.FetchIdentifier(identifier.Name); if (tableIdentifier.IsGlobal) { tableIdentifier.InitializedGlobally = true; } } } else { ResolveAdressor(assignment.AdressorExpressions[0], body, table); } }
public static void ComputeRefactoring(RefactoringContext context, BlockSyntax block) { if (context.IsAnyRefactoringEnabled( RefactoringIdentifiers.RemoveStatement, RefactoringIdentifiers.DuplicateStatement, RefactoringIdentifiers.CommentOutStatement)) { StatementSyntax statement = GetStatement(context, block, block.Parent); if (statement != null) { if (!EmbeddedStatement.IsEmbeddedStatement(statement) && statement.IsParentKind(SyntaxKind.Block)) { RegisterRefactoring(context, statement); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.CommentOutStatement)) { CommentOutRefactoring.RegisterRefactoring(context, statement); } } } }
public override string ToString() { return($"do\n{EmbeddedStatement.ToStringWithTrailNL()}while ({Condition})"); }
private static bool CanRefactor(RefactoringContext context, StatementSyntax statement) { return(context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(statement) && EmbeddedStatement.IsEmbeddedStatement(statement)); }
public static void ResolveIdentifierExpression(IdentifierExpression identifier, Table.Table table, EmbeddedStatement initializedInBlock, bool checkInit = true) { if (identifier.IdentifierState == IdentifierExpression.State.Decl) { if (!table.PushIdentifier(identifier, table == GlobalTable.Table ? true : false)) { ReportError(new IdentifierIsAlreadyDeclared(identifier.Name, identifier.SourceContext)); } if (initializedInBlock != null) { table.InitializeInBlock(identifier, initializedInBlock); } } else { if (!table.CheckIdentifier(identifier.Name)) { ReportError(new IdentifierIsNotDeclared(identifier.Name, identifier.SourceContext)); } else { TableIdentifier tableIdentifier = table.FetchIdentifier(identifier.Name); identifier.Type = tableIdentifier.Type; //check for initialization in this block if (!table.IsInitializedInBlock(identifier, initializedInBlock) && checkInit && !tableIdentifier.InitializedGlobally) { ReportError(new IdentifierIsNotInitialized(identifier.Name, identifier.SourceContext)); } } } }