public void Parser_Parse_Query_Ordered_WithMultipleColumns()
{
const string text = @"
SELECT *
ORDER BY 1, 2
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.OrderedQuery);
enumerator.AssertNode(SyntaxKind.SelectQuery);
enumerator.AssertNode(SyntaxKind.SelectClause);
enumerator.AssertToken(SyntaxKind.SelectKeyword, @"SELECT");
enumerator.AssertNode(SyntaxKind.WildcardSelectColumn);
enumerator.AssertToken(SyntaxKind.AsteriskToken, @"*");
enumerator.AssertToken(SyntaxKind.OrderKeyword, @"ORDER");
enumerator.AssertToken(SyntaxKind.ByKeyword, @"BY");
enumerator.AssertNode(SyntaxKind.OrderByColumn);
enumerator.AssertNode(SyntaxKind.LiteralExpression);
enumerator.AssertToken(SyntaxKind.NumericLiteralToken, @"1");
enumerator.AssertToken(SyntaxKind.CommaToken, @",");
enumerator.AssertNode(SyntaxKind.OrderByColumn);
enumerator.AssertNode(SyntaxKind.LiteralExpression);
enumerator.AssertToken(SyntaxKind.NumericLiteralToken, @"2");
}
}
public void Parser_Parse_Query_GroupByClause_WithMultipleColumns()
{
const string text = @"
SELECT *
FROM Employees e
{GROUP BY e.Country, e.City}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.GroupByClause);
enumerator.AssertToken(SyntaxKind.GroupKeyword, @"GROUP");
enumerator.AssertToken(SyntaxKind.ByKeyword, @"BY");
enumerator.AssertNode(SyntaxKind.GroupByColumn);
enumerator.AssertNode(SyntaxKind.PropertyAccessExpression);
enumerator.AssertNode(SyntaxKind.NameExpression);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"e");
enumerator.AssertToken(SyntaxKind.DotToken, @".");
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"Country");
enumerator.AssertToken(SyntaxKind.CommaToken, @",");
enumerator.AssertNode(SyntaxKind.GroupByColumn);
enumerator.AssertNode(SyntaxKind.PropertyAccessExpression);
enumerator.AssertNode(SyntaxKind.NameExpression);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"e");
enumerator.AssertToken(SyntaxKind.DotToken, @".");
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"City");
}
}
public void ParseNestedBlockExpression()
{
var text = "{{}}";
var expression = SyntaxTree.Parse(text).Root;
using var e = new AssertingEnumerator(expression);
//└──ExpressionStatement
// ├──BlockExpression
// │ ├──OpenBraceToken
// │ ├──BlockExpression
// │ │ ├──OpenBraceToken
// │ │ ├──UnitExpression
// │ │ │ ├──CloseBraceToken
// │ │ │ └──CloseBraceToken
// │ │ └──CloseBraceToken
// │ └──CloseBraceToken
// └──NewLineToken
e.AssertNode(SyntaxKind.CompilationUnit);
e.AssertNode(SyntaxKind.GlobalStatement);
e.AssertNode(SyntaxKind.ExpressionStatement);
e.AssertNode(SyntaxKind.BlockExpression);
e.AssertToken(SyntaxKind.OpenBraceToken, "{");
e.AssertNode(SyntaxKind.BlockExpression);
e.AssertToken(SyntaxKind.OpenBraceToken, "{");
e.AssertNode(SyntaxKind.UnitExpression);
e.AssertToken(SyntaxKind.OpenParenToken, "(");
e.AssertToken(SyntaxKind.CloseParenToken, ")");
e.AssertToken(SyntaxKind.CloseBraceToken, "}");
e.AssertToken(SyntaxKind.CloseBraceToken, "}");
e.AssertToken(SyntaxKind.EndOfInputToken, "");
}
public void Parser_Parse_Query_CommonTableExpression_WithRecursiveKeyword()
{
const string text = @"
WITH RECURSIVE CTE AS (
SELECT *
)
SELECT *
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.CommonTableExpressionQuery);
enumerator.AssertToken(SyntaxKind.WithKeyword, @"WITH");
enumerator.AssertNode(SyntaxKind.CommonTableExpression);
enumerator.AssertToken(SyntaxKind.RecursiveKeyword, @"RECURSIVE");
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"CTE");
enumerator.AssertToken(SyntaxKind.AsKeyword, @"AS");
enumerator.AssertToken(SyntaxKind.LeftParenthesisToken, @"(");
enumerator.AssertNode(SyntaxKind.SelectQuery);
enumerator.AssertNode(SyntaxKind.SelectClause);
enumerator.AssertToken(SyntaxKind.SelectKeyword, @"SELECT");
enumerator.AssertNode(SyntaxKind.WildcardSelectColumn);
enumerator.AssertToken(SyntaxKind.AsteriskToken, @"*");
enumerator.AssertToken(SyntaxKind.RightParenthesisToken, @")");
enumerator.AssertNode(SyntaxKind.SelectQuery);
enumerator.AssertNode(SyntaxKind.SelectClause);
enumerator.AssertToken(SyntaxKind.SelectKeyword, @"SELECT");
enumerator.AssertNode(SyntaxKind.WildcardSelectColumn);
enumerator.AssertToken(SyntaxKind.AsteriskToken, @"*");
}
}
public void Parser_Parse_Table_Derived_WithAsKeyword()
{
const string text = @"
SELECT *
FROM {(SELECT * FROM Employees) AS d}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.DerivedTableReference);
enumerator.AssertToken(SyntaxKind.LeftParenthesisToken, @"(");
enumerator.AssertNode(SyntaxKind.SelectQuery);
enumerator.AssertNode(SyntaxKind.SelectClause);
enumerator.AssertToken(SyntaxKind.SelectKeyword, @"SELECT");
enumerator.AssertNode(SyntaxKind.WildcardSelectColumn);
enumerator.AssertToken(SyntaxKind.AsteriskToken, @"*");
enumerator.AssertNode(SyntaxKind.FromClause);
enumerator.AssertToken(SyntaxKind.FromKeyword, @"FROM");
enumerator.AssertNode(SyntaxKind.NamedTableReference);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"Employees");
enumerator.AssertToken(SyntaxKind.RightParenthesisToken, @")");
enumerator.AssertToken(SyntaxKind.AsKeyword, @"AS");
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"d");
}
}
public void Parser_Parse_Table_InnerJoined_WithInnerJoinKeywords()
{
const string text = @"
SELECT *
FROM {Employees e
JOIN EmployeeTerritories et ON et.EmployeeID = e.EmployeeID}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.InnerJoinedTableReference);
enumerator.AssertNode(SyntaxKind.NamedTableReference);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"Employees");
enumerator.AssertNode(SyntaxKind.Alias);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"e");
enumerator.AssertToken(SyntaxKind.JoinKeyword, @"JOIN");
enumerator.AssertNode(SyntaxKind.NamedTableReference);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"EmployeeTerritories");
enumerator.AssertNode(SyntaxKind.Alias);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"et");
enumerator.AssertToken(SyntaxKind.OnKeyword, @"ON");
enumerator.AssertNode(SyntaxKind.EqualExpression);
enumerator.AssertNode(SyntaxKind.PropertyAccessExpression);
enumerator.AssertNode(SyntaxKind.NameExpression);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"et");
enumerator.AssertToken(SyntaxKind.DotToken, @".");
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"EmployeeID");
enumerator.AssertToken(SyntaxKind.EqualsToken, @"=");
enumerator.AssertNode(SyntaxKind.PropertyAccessExpression);
enumerator.AssertNode(SyntaxKind.NameExpression);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"e");
enumerator.AssertToken(SyntaxKind.DotToken, @".");
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"EmployeeID");
}
}
public void ParseForExpressionWithLineBreaks()
{
var text = AnnotatedText.Parse(
@"
for (x <- 0 to 5)
x
"
);
var tree = SyntaxTree.Parse(text.Text);
Assert.Empty(tree.Diagnostics);
var expression = tree.Root;
using var e = new AssertingEnumerator(expression);
//└──CompilationUnit
// ├──ExpressionStatement
// │ ├──ForExpression
// │ │ ├──ForKeyword
// │ │ ├──OpenParenToken
// │ │ ├──NameExpression
// │ │ │ └──IdentifierToken
// │ │ ├──LessThanDashToken
// │ │ ├──LiteralExpression
// │ │ │ └──NumberToken 0
// │ │ ├──ToKeyword
// │ │ ├──LiteralExpression
// │ │ │ └──NumberToken 5
// │ │ ├──CloseParenToken
// │ │ └──NameExpression
// │ │ └──IdentifierToken
// │ └──NewLineToken
// └──EndOfInputToken
e.AssertNode(SyntaxKind.CompilationUnit);
e.AssertNode(SyntaxKind.GlobalStatement);
e.AssertNode(SyntaxKind.ExpressionStatement);
e.AssertNode(SyntaxKind.ForExpression);
e.AssertToken(SyntaxKind.ForKeyword, "for");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertToken(SyntaxKind.OpenParenToken, "(");
e.AssertToken(SyntaxKind.IdentifierToken, "x");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertToken(SyntaxKind.LessThanDashToken, "<-");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertNode(SyntaxKind.LiteralExpression);
e.AssertToken(SyntaxKind.NumberToken, "0");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertToken(SyntaxKind.ToKeyword, "to");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertNode(SyntaxKind.LiteralExpression);
e.AssertToken(SyntaxKind.NumberToken, "5");
e.AssertToken(SyntaxKind.CloseParenToken, ")");
e.AssertTrivia(SyntaxKind.EndOfLineTrivia);
e.AssertNode(SyntaxKind.IdentifierName);
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertToken(SyntaxKind.IdentifierToken, "x");
e.AssertToken(SyntaxKind.EndOfInputToken, "");
}
public void ParseNestedNonUnitBlockExpression()
{
var text = AnnotatedText.Parse(
@"
{
val x = 5
5
}"
);
var tree = SyntaxTree.Parse(text.Text);
Assert.Empty(tree.Diagnostics);
var expression = tree.Root;
using var e = new AssertingEnumerator(expression);
//└──ExpressionStatement
// ├──BlockExpression
// │ ├──OpenBraceToken
// │ ├──BlockExpression
// │ │ ├──OpenBraceToken
// │ │ ├──UnitExpression
// │ │ │ ├──CloseBraceToken
// │ │ │ └──CloseBraceToken
// │ │ └──CloseBraceToken
// │ └──CloseBraceToken
// └──NewLineToken
e.AssertNode(SyntaxKind.CompilationUnit);
e.AssertNode(SyntaxKind.GlobalStatement);
e.AssertNode(SyntaxKind.ExpressionStatement);
e.AssertNode(SyntaxKind.BlockExpression);
e.AssertToken(SyntaxKind.OpenBraceToken, "{");
e.AssertTrivia(SyntaxKind.EndOfLineTrivia);
e.AssertNode(SyntaxKind.VariableDeclarationStatement);
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertToken(SyntaxKind.ValKeyword, "val");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertToken(SyntaxKind.IdentifierToken, "x");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertNode(SyntaxKind.Initializer);
e.AssertToken(SyntaxKind.EqualsToken, "=");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertNode(SyntaxKind.LiteralExpression);
e.AssertToken(SyntaxKind.NumberToken, "5");
e.AssertTrivia(SyntaxKind.EndOfLineTrivia);
e.AssertNode(SyntaxKind.LiteralExpression);
e.AssertTrivia(SyntaxKind.WhitespaceTrivia, " ");
e.AssertToken(SyntaxKind.NumberToken, "5");
e.AssertTrivia(SyntaxKind.EndOfLineTrivia);
e.AssertToken(SyntaxKind.CloseBraceToken, "}");
e.AssertToken(SyntaxKind.EndOfInputToken, "");
}
public void Parser_BinaryExpression_HonorsPrecedences(SyntaxKind op1, SyntaxKind op2)
{
var op1Precedence = SyntaxInfo.GetBinaryOperatorPrecedence(op1);
var op2Precedence = SyntaxInfo.GetBinaryOperatorPrecedence(op2);
var op1Text = SyntaxInfo.GetText(op1);
var op2Text = SyntaxInfo.GetText(op2);
Debug.Assert(op1Text != null);
Debug.Assert(op2Text != null);
var text = $"a {op1Text} b {op2Text} c";
var expression = ParseExpression(text);
using var e = new AssertingEnumerator(expression);
if (op1Precedence >= op2Precedence)
{
// op2
// / \
// op1 c
// / \
// a b
e.AssertNode(SyntaxKind.BinaryExpression);
e.AssertNode(SyntaxKind.BinaryExpression);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "a");
e.AssertToken(op1, op1Text);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "b");
e.AssertToken(op2, op2Text);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "c");
}
else
{
// op1
// / \
// a op2
// / \
// b c
e.AssertNode(SyntaxKind.BinaryExpression);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "a");
e.AssertToken(op1, op1Text);
e.AssertNode(SyntaxKind.BinaryExpression);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "b");
e.AssertToken(op2, op2Text);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "c");
}
}
public void Parser_Parse_Query_WildcardSelectColumn_WithoutTableAlias()
{
const string text = @"
SELECT {*}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.WildcardSelectColumn);
enumerator.AssertToken(SyntaxKind.AsteriskToken, @"*");
}
}
public void Parser_Parse_Query_Alias_WithoutAsKeyword()
{
const string text = @"
SELECT 1 {X}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.Alias);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"X");
}
}
public void HonorPrecedences_GivenBinaryExpression(SyntaxKind op1, SyntaxKind op2)
{
var op1Precedence = op1.GetBinaryOperatorPrecedence();
var op2Precedence = op2.GetBinaryOperatorPrecedence();
var op1Text = op1.GetText();
var op2Text = op2.GetText();
var text = $"a {op1Text} b {op2Text} c";
var expressionSyntax = ParseExpression(text);
if (op1Precedence >= op2Precedence)
{
// op2
// / \
// op1 c
// / \
// a b
using (var asserter = new AssertingEnumerator(expressionSyntax))
{
asserter.AssertNode(SyntaxKind.BinaryExpression);
asserter.AssertNode(SyntaxKind.BinaryExpression);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "a");
asserter.AssertToken(op1, op1Text);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "b");
asserter.AssertToken(op2, op2Text);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "c");
}
}
else
{
// op1
// / \
// a op2
// / \
// b c
using (var asserter = new AssertingEnumerator(expressionSyntax))
{
asserter.AssertNode(SyntaxKind.BinaryExpression);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "a");
asserter.AssertToken(op1, op1Text);
asserter.AssertNode(SyntaxKind.BinaryExpression);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "b");
asserter.AssertToken(op2, op2Text);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "c");
}
}
}
public void ParseUsingDirectives()
{
var text = AnnotatedText.Parse(
@"
using System
using System.Collections.Immutable
using System.Diagnostics
"
);
var tree = SyntaxTree.Parse(text.Text);
Assert.Empty(tree.Diagnostics);
var expression = tree.Root;
using var e = new AssertingEnumerator(expression);
e.AssertNode(SyntaxKind.CompilationUnit);
e.AssertNode(SyntaxKind.UsingDirective);
e.AssertToken(SyntaxKind.UsingKeyword, "using");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia);
e.AssertNode(SyntaxKind.IdentifierName);
e.AssertToken(SyntaxKind.IdentifierToken, "System");
e.AssertTrivia(SyntaxKind.EndOfLineTrivia);
e.AssertNode(SyntaxKind.UsingDirective);
e.AssertToken(SyntaxKind.UsingKeyword, "using");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia);
e.AssertNode(SyntaxKind.QualifiedName);
e.AssertNode(SyntaxKind.QualifiedName);
e.AssertNode(SyntaxKind.IdentifierName);
e.AssertToken(SyntaxKind.IdentifierToken, "System");
e.AssertToken(SyntaxKind.DotToken, ".");
e.AssertNode(SyntaxKind.IdentifierName);
e.AssertToken(SyntaxKind.IdentifierToken, "Collections");
e.AssertToken(SyntaxKind.DotToken, ".");
e.AssertNode(SyntaxKind.IdentifierName);
e.AssertToken(SyntaxKind.IdentifierToken, "Immutable");
e.AssertTrivia(SyntaxKind.EndOfLineTrivia);
e.AssertNode(SyntaxKind.UsingDirective);
e.AssertToken(SyntaxKind.UsingKeyword, "using");
e.AssertTrivia(SyntaxKind.WhitespaceTrivia);
e.AssertNode(SyntaxKind.QualifiedName);
e.AssertNode(SyntaxKind.IdentifierName);
e.AssertToken(SyntaxKind.IdentifierToken, "System");
e.AssertToken(SyntaxKind.DotToken, ".");
e.AssertNode(SyntaxKind.IdentifierName);
e.AssertToken(SyntaxKind.IdentifierToken, "Diagnostics");
e.AssertToken(SyntaxKind.EndOfInputToken, "");
}
public void Parser_Parse_Table_Named_WithoutAlias()
{
const string text = @"
SELECT *
FROM {Employees}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.NamedTableReference);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"Employees");
}
}
public void Parser_Parse_Query_TopClause()
{
const string text = @"
SELECT {TOP 10} *
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.TopClause);
enumerator.AssertToken(SyntaxKind.TopKeyword, @"TOP");
enumerator.AssertToken(SyntaxKind.NumericLiteralToken, @"10");
}
}
public void Parser_Parse_Query_ExpressionSelectColumn_WithoutAlias()
{
const string text = @"
SELECT {1}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.ExpressionSelectColumn);
enumerator.AssertNode(SyntaxKind.LiteralExpression);
enumerator.AssertToken(SyntaxKind.NumericLiteralToken, @"1");
}
}
public void Parser_UnaryExpression_HonorsPrecedences(SyntaxKind unaryKind, SyntaxKind binaryKind)
{
var unaryPrecedence = SyntaxInfo.GetUnaryOperatorPrecedence(unaryKind);
var binaryPrecedence = SyntaxInfo.GetBinaryOperatorPrecedence(binaryKind);
var unaryText = SyntaxInfo.GetText(unaryKind);
var binaryText = SyntaxInfo.GetText(binaryKind);
Debug.Assert(unaryText != null);
Debug.Assert(binaryText != null);
var text = $"{unaryText} a {binaryText} b";
var expression = ParseExpression(text);
using var e = new AssertingEnumerator(expression);
if (unaryPrecedence >= binaryPrecedence)
{
// binary
// / \
// unary b
// |
// a
e.AssertNode(SyntaxKind.BinaryExpression);
e.AssertNode(SyntaxKind.UnaryExpression);
e.AssertToken(unaryKind, unaryText);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "a");
e.AssertToken(binaryKind, binaryText);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "b");
}
else
{
// unary
// |
// binary
// / \
// a b
e.AssertNode(SyntaxKind.UnaryExpression);
e.AssertToken(unaryKind, unaryText);
e.AssertNode(SyntaxKind.BinaryExpression);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "a");
e.AssertToken(binaryKind, binaryText);
e.AssertNode(SyntaxKind.NameExpression);
e.AssertToken(SyntaxKind.Identifier, "b");
}
}
public void Parser_Parse_Query_TopClause_WithMissingLimit()
{
const string text = @"
SELECT {TOP }*
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.TopClause);
enumerator.AssertToken(SyntaxKind.TopKeyword, @"TOP");
enumerator.AssertTokenMissing(SyntaxKind.NumericLiteralToken);
enumerator.AssertDiagnostic(DiagnosticId.TokenExpected, @"Found '*' but expected '<Numeric Literal>'.");
}
}
public void Parser_Parse_Query_TopClause_WithInvalidLimit_NumericLiteral()
{
const string text = @"
SELECT {TOP 10.3} *
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.TopClause);
enumerator.AssertToken(SyntaxKind.TopKeyword, @"TOP");
enumerator.AssertToken(SyntaxKind.NumericLiteralToken, @"10.3");
enumerator.AssertDiagnostic(DiagnosticId.InvalidInteger, @"'10.3' is not a valid integer.");
}
}
public void HonorPrecedences_GivenUnaryExpression(SyntaxKind unaaryKind, SyntaxKind binaryKind)
{
var unaryPrecedence = unaaryKind.GetUnaryOperatorPrecedence();
var binaryPrecedence = binaryKind.GetBinaryOperatorPrecedence();
var unaryText = unaaryKind.GetText();
var binaryText = binaryKind.GetText();
var text = $"{unaryText} a {binaryText} b";
var expressionSyntax = ParseExpression(text);
if (unaryPrecedence >= binaryPrecedence)
{
// op2
// / \
// op1 b
// |
// a
using (var asserter = new AssertingEnumerator(expressionSyntax))
{
asserter.AssertNode(SyntaxKind.BinaryExpression);
asserter.AssertNode(SyntaxKind.UnaryExpression);
asserter.AssertToken(unaaryKind, unaryText);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "a");
asserter.AssertToken(binaryKind, binaryText);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "b");
}
}
else
{
// op2
// |
// op1
// / \
// a b
using (var asserter = new AssertingEnumerator(expressionSyntax))
{
asserter.AssertNode(SyntaxKind.UnaryExpression);
asserter.AssertNode(SyntaxKind.BinaryExpression);
asserter.AssertToken(unaaryKind, unaryText);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "a");
asserter.AssertToken(binaryKind, binaryText);
asserter.AssertNode(SyntaxKind.NameExpression);
asserter.AssertToken(SyntaxKind.IdentifierToken, "b");
}
}
}
public void Parser_Parse_Query_CommonTableExpressionColumnName()
{
const string text = @"
WITH CTE ({x}, y) AS (
SELECT *
)
SELECT *
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.CommonTableExpressionColumnName);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"x");
}
}
public void Parser_Parse_Query_OrderByColumn_WithoutModifier()
{
const string text = @"
SELECT *
FROM Employees
ORDER BY {FirstName}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.OrderByColumn);
enumerator.AssertNode(SyntaxKind.NameExpression);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"FirstName");
}
}
public void Parser_Parse_Query_GroupByColumn()
{
const string text = @"
SELECT *
FROM Employees e
GROUP BY {Country}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.GroupByColumn);
enumerator.AssertNode(SyntaxKind.NameExpression);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"Country");
}
}
public void ParseLineCommentOnly()
{
var text = @"// taco";
var tree = SyntaxTree.Parse(text);
Assert.Empty(tree.Diagnostics);
var expression = tree.Root;
using var e = new AssertingEnumerator(expression);
e.AssertNode(SyntaxKind.CompilationUnit);
e.AssertTrivia(SyntaxKind.LineCommentTrivia, "// taco");
e.AssertToken(SyntaxKind.EndOfInputToken, "");
}
public void Parser_Parse_Query_FromClause()
{
const string text = @"
SELECT *
{FROM Employees}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.FromClause);
enumerator.AssertToken(SyntaxKind.FromKeyword, @"FROM");
enumerator.AssertNode(SyntaxKind.NamedTableReference);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"Employees");
}
}
public void Parser_Parse_Table_Parenthesized_WithNamed()
{
const string text = @"
SELECT *
FROM {(Employees)}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.ParenthesizedTableReference);
enumerator.AssertToken(SyntaxKind.LeftParenthesisToken, @"(");
enumerator.AssertNode(SyntaxKind.NamedTableReference);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"Employees");
enumerator.AssertToken(SyntaxKind.RightParenthesisToken, @")");
}
}
public void Parser_Parse_Query_Select_WithSelectClause()
{
const string text = @"
SELECT 1
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.SelectQuery);
enumerator.AssertNode(SyntaxKind.SelectClause);
enumerator.AssertToken(SyntaxKind.SelectKeyword, @"SELECT");
enumerator.AssertNode(SyntaxKind.ExpressionSelectColumn);
enumerator.AssertNode(SyntaxKind.LiteralExpression);
enumerator.AssertToken(SyntaxKind.NumericLiteralToken, @"1");
}
}
public void Parser_Parse_Query_WhereClause()
{
const string text = @"
SELECT *
FROM Employees e
{WHERE TRUE}
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.WhereClause);
enumerator.AssertToken(SyntaxKind.WhereKeyword, @"WHERE");
enumerator.AssertNode(SyntaxKind.LiteralExpression);
enumerator.AssertToken(SyntaxKind.TrueKeyword, @"TRUE");
}
}
public void Parser_Parse_Query_SelectClause()
{
const string text = @"
SELECT x
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.SelectQuery);
enumerator.AssertNode(SyntaxKind.SelectClause);
enumerator.AssertToken(SyntaxKind.SelectKeyword, @"SELECT");
enumerator.AssertNode(SyntaxKind.ExpressionSelectColumn);
enumerator.AssertNode(SyntaxKind.NameExpression);
enumerator.AssertToken(SyntaxKind.IdentifierToken, @"x");
}
}
public void Parser_Parse_Query_TopClause_WithTies_WithoutWithKeyword()
{
const string text = @"
SELECT {TOP 10 TIES} *
";
using (var enumerator = AssertingEnumerator.ForQuery(text))
{
enumerator.AssertNode(SyntaxKind.TopClause);
enumerator.AssertToken(SyntaxKind.TopKeyword, @"TOP");
enumerator.AssertToken(SyntaxKind.NumericLiteralToken, @"10");
enumerator.AssertTokenMissing(SyntaxKind.WithKeyword);
enumerator.AssertDiagnostic(DiagnosticId.TokenExpected, @"Found 'TIES' but expected 'WITH'.");
enumerator.AssertToken(SyntaxKind.TiesKeyword, @"TIES");
}
}
