private IEnumerable <DiagnosticRecord> FindPipeViolations(TokenOperations tokenOperations) { foreach (var pipe in tokenOperations.GetTokenNodes(TokenKind.Pipe)) { if (pipe.Next == null || !IsPreviousTokenOnSameLine(pipe) || pipe.Next.Value.Kind == TokenKind.Pipe || pipe.Next.Value.Kind == TokenKind.NewLine || pipe.Next.Value.Kind == TokenKind.LineContinuation ) { continue; } if (!IsNextTokenApartByWhitespace(pipe, out bool hasRedundantWhitespace)) { if (CheckPipeForRedundantWhitespace && hasRedundantWhitespace || CheckPipe && !hasRedundantWhitespace) { yield return(new DiagnosticRecord( GetError(ErrorKind.AfterPipe), pipe.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections(pipe.Previous.Value, pipe.Value, pipe.Next.Value, true, false).ToList())); } } } foreach (var pipe in tokenOperations.GetTokenNodes(TokenKind.Pipe)) { if (pipe.Previous == null || !IsPreviousTokenOnSameLine(pipe) || pipe.Previous.Value.Kind == TokenKind.Pipe || pipe.Previous.Value.Kind == TokenKind.NewLine || pipe.Previous.Value.Kind == TokenKind.LineContinuation ) { continue; } if (!IsPreviousTokenApartByWhitespace(pipe, out bool hasRedundantWhitespace)) { if (CheckPipeForRedundantWhitespace && hasRedundantWhitespace || CheckPipe && !hasRedundantWhitespace) { yield return(new DiagnosticRecord( GetError(ErrorKind.BeforePipe), pipe.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections(pipe.Previous.Value, pipe.Value, pipe.Next.Value, false, true).ToList())); } } } }
private IEnumerable <DiagnosticRecord> FindInnerBraceViolations(TokenOperations tokenOperations) { foreach (var lCurly in tokenOperations.GetTokenNodes(TokenKind.LCurly)) { if (lCurly.Next == null || !IsPreviousTokenOnSameLine(lCurly) || lCurly.Next.Value.Kind == TokenKind.NewLine || lCurly.Next.Value.Kind == TokenKind.LineContinuation || lCurly.Next.Value.Kind == TokenKind.RCurly ) { continue; } if (!IsNextTokenApartByWhitespace(lCurly)) { yield return(new DiagnosticRecord( GetError(ErrorKind.AfterOpeningBrace), lCurly.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections(lCurly.Previous.Value, lCurly.Value, lCurly.Next.Value, true, false).ToList())); } } foreach (var rCurly in tokenOperations.GetTokenNodes(TokenKind.RCurly)) { if (rCurly.Previous == null || !IsPreviousTokenOnSameLine(rCurly) || rCurly.Previous.Value.Kind == TokenKind.LCurly || rCurly.Previous.Value.Kind == TokenKind.NewLine || rCurly.Previous.Value.Kind == TokenKind.LineContinuation || rCurly.Previous.Value.Kind == TokenKind.AtCurly ) { continue; } if (!IsPreviousTokenApartByWhitespace(rCurly)) { yield return(new DiagnosticRecord( GetError(ErrorKind.BeforeClosingBrace), rCurly.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections(rCurly.Previous.Value, rCurly.Value, rCurly.Next.Value, false, true).ToList())); } } }
private IEnumerable <DiagnosticRecord> FindOperatorViolations(TokenOperations tokenOperations) { Func <LinkedListNode <Token>, bool> predicate = tokenNode => { return(tokenNode.Previous != null && IsPreviousTokenOnSameLine(tokenNode) && IsPreviousTokenApartByWhitespace(tokenNode)); }; foreach (var tokenNode in tokenOperations.GetTokenNodes(IsOperator)) { var hasWhitespaceBefore = predicate(tokenNode); var hasWhitespaceAfter = predicate(tokenNode.Next); if (!hasWhitespaceAfter || !hasWhitespaceBefore) { yield return(new DiagnosticRecord( GetError(ErrorKind.Operator), tokenNode.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections( tokenNode.Previous.Value, tokenNode.Value, tokenNode.Next.Value, hasWhitespaceBefore, hasWhitespaceAfter))); } } }
private IEnumerable <DiagnosticRecord> FindSeparatorViolations(TokenOperations tokenOperations) { Func <LinkedListNode <Token>, bool> predicate = node => { return(node.Next != null && node.Next.Value.Kind != TokenKind.NewLine && node.Next.Value.Kind != TokenKind.EndOfInput && // semicolon can be followed by end of input !IsPreviousTokenApartByWhitespace(node.Next)); }; foreach (var tokenNode in tokenOperations.GetTokenNodes(IsSeparator).Where(predicate)) { var errorKind = tokenNode.Value.Kind == TokenKind.Comma ? ErrorKind.SeparatorComma : ErrorKind.SeparatorSemi; yield return(getDiagnosticRecord( tokenNode.Value, errorKind, GetCorrections( tokenNode.Previous.Value, tokenNode.Value, tokenNode.Next.Value, true, false))); } }
private static List <Tuple <IScriptExtent, IScriptExtent> > GetExtents( TokenOperations tokenOps, HashtableAst hashtableAst) { var nodeTuples = new List <Tuple <IScriptExtent, IScriptExtent> >(); foreach (var kvp in hashtableAst.KeyValuePairs) { var keyStartOffset = kvp.Item1.Extent.StartOffset; bool keyStartOffSetReached = false; var keyTokenNode = tokenOps.GetTokenNodes( token => { if (keyStartOffSetReached) { return(token.Kind == TokenKind.Equals); } if (token.Extent.StartOffset == keyStartOffset) { keyStartOffSetReached = true; } return(false); }).FirstOrDefault(); if (keyTokenNode == null || keyTokenNode.Value == null) { continue; } var assignmentToken = keyTokenNode.Value.Extent; nodeTuples.Add(new Tuple <IScriptExtent, IScriptExtent>( kvp.Item1.Extent, assignmentToken)); } return(nodeTuples); }
private IEnumerable <DiagnosticRecord> FindOperatorViolations(TokenOperations tokenOperations) { foreach (var tokenNode in tokenOperations.GetTokenNodes(IsOperator)) { if (tokenNode.Previous == null || tokenNode.Next == null || tokenNode.Value.Kind == TokenKind.DotDot) { continue; } var hasWhitespaceBefore = IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode); var hasWhitespaceAfter = IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode.Next); if (!hasWhitespaceAfter || !hasWhitespaceBefore) { yield return(new DiagnosticRecord( GetError(ErrorKind.Operator), tokenNode.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections( tokenNode.Previous.Value, tokenNode.Value, tokenNode.Next.Value, hasWhitespaceBefore, hasWhitespaceAfter))); } } }
private IEnumerable <DiagnosticRecord> FindOpenBraceViolations(TokenOperations tokenOperations) { foreach (var lcurly in tokenOperations.GetTokenNodes(TokenKind.LCurly)) { if (lcurly.Previous == null || !IsPreviousTokenOnSameLine(lcurly) || lcurly.Previous.Value.Kind == TokenKind.LCurly || ((lcurly.Previous.Value.TokenFlags & TokenFlags.MemberName) == TokenFlags.MemberName)) { continue; } if (!IsPreviousTokenApartByWhitespace(lcurly)) { yield return(new DiagnosticRecord( GetError(ErrorKind.Brace), lcurly.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections(lcurly.Previous.Value, lcurly.Value, lcurly.Next.Value, false, true).ToList())); } } }
private static List <Tuple <IScriptExtent, IScriptExtent> > GetExtents( TokenOperations tokenOps, HashtableAst hashtableAst) { var nodeTuples = new List <Tuple <IScriptExtent, IScriptExtent> >(); foreach (var kvp in hashtableAst.KeyValuePairs) { var keyStartOffset = kvp.Item1.Extent.StartOffset; var keyTokenNode = tokenOps.GetTokenNodes( token => token.Extent.StartOffset == keyStartOffset).FirstOrDefault(); if (keyTokenNode == null || keyTokenNode.Next == null || keyTokenNode.Next.Value.Kind != TokenKind.Equals) { return(null); } nodeTuples.Add(new Tuple <IScriptExtent, IScriptExtent>( kvp.Item1.Extent, keyTokenNode.Next.Value.Extent)); } return(nodeTuples); }
private IEnumerable <DiagnosticRecord> FindOperatorViolations(TokenOperations tokenOperations) { foreach (var tokenNode in tokenOperations.GetTokenNodes(IsOperator)) { if (tokenNode.Previous == null || tokenNode.Next == null || tokenNode.Value.Kind == TokenKind.DotDot) { continue; } // exclude unary operator for cases like $foo.bar(-$Var) if (TokenTraits.HasTrait(tokenNode.Value.Kind, TokenFlags.UnaryOperator) && tokenNode.Previous.Value.Kind == TokenKind.LParen && tokenNode.Next.Value.Kind == TokenKind.Variable) { continue; } // exclude assignment operator inside of multi-line hash tables if requested if (IgnoreAssignmentOperatorInsideHashTable && tokenNode.Value.Kind == TokenKind.Equals) { Ast containingAst = tokenOperations.GetAstPosition(tokenNode.Value); if (containingAst is HashtableAst && containingAst.Extent.EndLineNumber != containingAst.Extent.StartLineNumber) { continue; } } var hasWhitespaceBefore = IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode); var hasWhitespaceAfter = tokenNode.Next.Value.Kind == TokenKind.NewLine || IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode.Next); if (!hasWhitespaceAfter || !hasWhitespaceBefore) { yield return(new DiagnosticRecord( GetError(ErrorKind.Operator), tokenNode.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections( tokenNode.Previous.Value, tokenNode.Value, tokenNode.Next.Value, hasWhitespaceBefore, hasWhitespaceAfter))); } } }
private IEnumerable <DiagnosticRecord> FindOperatorViolations(TokenOperations tokenOperations) { foreach (var tokenNode in tokenOperations.GetTokenNodes(IsOperator)) { if (tokenNode.Previous == null || tokenNode.Next == null || tokenNode.Value.Kind == TokenKind.DotDot) { continue; } // exclude unary operator for cases like $foo.bar(-$Var) if (TokenTraits.HasTrait(tokenNode.Value.Kind, TokenFlags.UnaryOperator) && tokenNode.Previous.Value.Kind == TokenKind.LParen && tokenNode.Next.Value.Kind == TokenKind.Variable) { continue; } var hasWhitespaceBefore = IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode); var hasWhitespaceAfter = tokenNode.Next.Value.Kind == TokenKind.NewLine || IsPreviousTokenOnSameLineAndApartByWhitespace(tokenNode.Next); if (!hasWhitespaceAfter || !hasWhitespaceBefore) { yield return(new DiagnosticRecord( GetError(ErrorKind.Operator), tokenNode.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections( tokenNode.Previous.Value, tokenNode.Value, tokenNode.Next.Value, hasWhitespaceBefore, hasWhitespaceAfter))); } } }
private IEnumerable <DiagnosticRecord> FindOpenParenViolations(TokenOperations tokenOperations) { foreach (var lparen in tokenOperations.GetTokenNodes(TokenKind.LParen)) { if (lparen.Previous != null && IsPreviousTokenOnSameLine(lparen) && TokenTraits.HasTrait(lparen.Previous.Value.Kind, TokenFlags.Keyword) && IsKeyword(lparen.Previous.Value) && !IsPreviousTokenApartByWhitespace(lparen)) { yield return(new DiagnosticRecord( GetError(ErrorKind.Paren), lparen.Value.Extent, GetName(), GetDiagnosticSeverity(), tokenOperations.Ast.Extent.File, null, GetCorrections(lparen.Previous.Value, lparen.Value, lparen.Next.Value, false, true).ToList())); } } }