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()));
}
}
}
