in src/Kusto.Language/Parser/CommandParserFactory.cs [639:1017]
private static IReadOnlyDictionary<string, ParserInfo> CreateRulesMap(QueryGrammar queryParser, Parser<LexicalToken, Command> command)
{
command = command ?? First(CommandGrammar.UnknownCommand, CommandGrammar.BadCommand);
var StringName =
Rule(Token(SyntaxKind.StringLiteralToken), token => (Name)new TokenName(token));
var RawGuidLiteral =
Convert(
And(
Match(t => IsHex(t.Text)),
ZeroOrMore(
And(
Match(t => t.Kind == SyntaxKind.MinusToken && t.Trivia.Length == 0),
Match(t => IsHex(t.Text) && t.Trivia.Length == 0)))),
(IReadOnlyList<LexicalToken> list) =>
{
var text = string.Concat(list.Select(e => e.Text));
return (Expression)new LiteralExpression(SyntaxKind.GuidLiteralExpression,
SyntaxToken.Literal(list[0].Trivia, text, SyntaxKind.GuidLiteralToken));
}).WithTag("<guid>");
var GuidLiteral =
Rule(
Token(SyntaxKind.GuidLiteralToken),
(token) => (Expression)new LiteralExpression(SyntaxKind.GuidLiteralExpression, token));
var AnyGuidLiteralOrString =
First(GuidLiteral, queryParser.StringLiteral, RawGuidLiteral);
var Name =
First(
queryParser.IdentifierName,
queryParser.BracketedName,
queryParser.BracedName,
StringName)
.WithTag("<name>");
var ColumnNameReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.Column))
.WithCompletionHint(Editor.CompletionHint.Column)
.WithTag("<column>");
var TableNameReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.Table))
.WithCompletionHint(Editor.CompletionHint.Table)
.WithTag("<table>");
var ExternalTableNameReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.ExternalTable))
.WithCompletionHint(Editor.CompletionHint.ExternalTable)
.WithTag("<externaltable>");
var MaterializedViewNameReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.MaterializedView))
.WithCompletionHint(Editor.CompletionHint.MaterializedView)
.WithTag("<materializedview>");
var DatabaseNameReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.Database))
.WithCompletionHint(Editor.CompletionHint.Database)
.WithTag("<database>");
var ClusterNameReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.Cluster))
.WithCompletionHint(Editor.CompletionHint.Cluster)
.WithTag("<cluster>");
var DatabaseFunctionNameReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.Function))
.WithCompletionHint(Editor.CompletionHint.DatabaseFunction)
.WithTag("<function>");
var DatabaseOrTableReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.Database | SymbolMatch.Table))
.WithCompletionHint(Editor.CompletionHint.Database | Editor.CompletionHint.Table)
.WithTag("<database_or_table>");
var DatabaseTableNameReference =
ApplyZeroOrMore(
DatabaseOrTableReference,
_left =>
Rule(_left, Token(".").Hide(), Required(TableNameReference, Q.MissingNameReference),
(expr, dot, selector) => (Expression)new PathExpression(expr, dot, selector)))
.WithTag("<database_table>");
var DatabaseOrTableOrColumnReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.Database | SymbolMatch.Table | SymbolMatch.Column))
.WithCompletionHint(Editor.CompletionHint.Database | Editor.CompletionHint.Table | Editor.CompletionHint.Column)
.WithTag("<database_or_table_or_column>");
var DatabaseTableColumnNameReference =
ApplyZeroOrMore(
DatabaseOrTableOrColumnReference,
_left =>
Rule(_left, Token(".").Hide(), Required(DatabaseOrTableOrColumnReference, Q.MissingNameReference),
(expr, dot, selector) => (Expression)new PathExpression(expr, dot, selector)))
.WithTag("<database_table_column>");
var TableOrColumnReference =
Rule(Name, name => (Expression)new NameReference(name, SymbolMatch.Table | SymbolMatch.Column))
.WithCompletionHint(Editor.CompletionHint.Table | Editor.CompletionHint.Column)
.WithTag("<table_or_column>");
var TableColumnNameReference =
ApplyZeroOrMore(
TableOrColumnReference,
_left =>
Rule(_left, Token(".").Hide(), Required(TableOrColumnReference, Q.MissingNameReference),
(expr, dot, selector) => (Expression)new PathExpression(expr, dot, selector)))
.WithTag("<table_column>");
var KustoStringLiteralInfo =
new ParserInfo(
queryParser.StringLiteral.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Literal),
() => (SyntaxElement)Q.MissingStringLiteral());
var BracketedStringLiteral =
Convert(
And(
Token("["),
ZeroOrMore(Match(t =>
t.Text != "]"
&& t.Text != "["
&& !TextFacts.HasLineBreaks(t.Trivia)
&& !TextFacts.HasLineBreaks(t.Text))),
Optional(Token("]"))),
(IReadOnlyList<LexicalToken> list) =>
{
var text = string.Concat(list.Select(e => (e != list[0] ? e.Trivia : "") + e.Text));
return (Expression)new LiteralExpression(SyntaxKind.StringLiteralExpression,
SyntaxToken.Literal(list[0].Trivia, text, SyntaxKind.StringLiteralToken));
}).WithTag("<bracketed-string>");
var KustoBracketedStringLiteralInfo =
new ParserInfo(
BracketedStringLiteral.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Literal),
() => (SyntaxElement)Q.MissingStringLiteral());
var KustoGuidLiteralInfo =
new ParserInfo(
AnyGuidLiteralOrString.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Literal),
() => (SyntaxElement)Q.MissingValue());
var KustoValueInfo =
new ParserInfo(
First(GuidLiteral.Cast<SyntaxElement>(), queryParser.Literal.Cast<SyntaxElement>()),
new CustomElementDescriptor(hint: Editor.CompletionHint.Literal),
() => (SyntaxElement)Q.MissingValue());
var KustoTypeInfo =
new ParserInfo(
queryParser.ParamTypeExtended.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Syntax),
() => (SyntaxElement)Q.MissingType());
var NameDeclarationOrStringLiteral =
First(
queryParser.SimpleNameDeclarationExpression,
queryParser.StringLiteral);
var KustoNameDeclarationInfo =
new ParserInfo(
NameDeclarationOrStringLiteral.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.None),
() => (SyntaxElement)Q.MissingNameDeclaration());
var WildcardedNameDeclaration =
Rule(queryParser.WildcardedIdentifier,
id => new NameDeclaration(
new WildcardedName(id)));
var KustoWildcardedNameDeclarationInfo =
new ParserInfo(
WildcardedNameDeclaration.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.None),
() => (SyntaxElement)Q.MissingNameReference());;
// either name.wildname or wildname
var QualifiedWildcardedNameDeclaration =
First(
If(And(queryParser.SimpleNameDeclaration, Token("."), queryParser.WildcardedIdentifier),
Rule(queryParser.SimpleNameDeclaration, Token("."), Required(WildcardedNameDeclaration.Cast<Expression>(), Q.MissingNameReference),
(qual, dot, name) => (Expression)new PathExpression(qual, dot, name))),
WildcardedNameDeclaration.Cast<Expression>());
var KustoQualifiedWildcardedNameDeclarationInfo =
new ParserInfo(
QualifiedWildcardedNameDeclaration.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.None),
() => (SyntaxElement)Q.MissingNameReference()); ;
var KustoColumnNameInfo =
new ParserInfo(
ColumnNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Column),
() => (SyntaxElement)Q.MissingNameReference());
var KustoTableNameInfo =
new ParserInfo(
TableNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Table),
() => (SyntaxElement)Q.MissingNameReference());
var KustoExternalTableNameInfo =
new ParserInfo(
ExternalTableNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.ExternalTable),
() => (SyntaxElement)Q.MissingNameReference());
var KustoMaterializedViewNameInfo =
new ParserInfo(
MaterializedViewNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.MaterializedView),
() => (SyntaxElement)Q.MissingNameReference());
var KustoDatabaseNameInfo =
new ParserInfo(
DatabaseNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Database),
() => (SyntaxElement)Q.MissingNameReference());
var KustoDatabaseTableNameInfo =
new ParserInfo(
DatabaseTableNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Table),
() => (SyntaxElement)Q.MissingNameReference());
var KustoClusterNameInfo =
new ParserInfo(
ClusterNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Cluster),
() => (SyntaxElement)Q.MissingNameReference());
var KustoFunctionNameInfo =
new ParserInfo(
DatabaseFunctionNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(Editor.CompletionHint.Function),
() => (SyntaxElement)Q.MissingNameReference());
var KustoDatabaseTableColumnNameInfo =
new ParserInfo(
DatabaseTableColumnNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Column),
() => (SyntaxElement)Q.MissingNameReference());
var KustoTableColumnNameInfo =
new ParserInfo(
TableColumnNameReference.Cast<SyntaxElement>(),
new CustomElementDescriptor(hint: Editor.CompletionHint.Column),
() => (SyntaxElement)Q.MissingNameReference());
var KustoFunctionDeclaration =
new ParserInfo(
Rule(
queryParser.FunctionParameters,
queryParser.FunctionBody,
(p, b) => (SyntaxElement)new FunctionDeclaration(null, p, b)),
new CustomElementDescriptor(hint: Editor.CompletionHint.Syntax),
() => new FunctionDeclaration(
null,
new FunctionParameters(
CreateMissingToken(SyntaxKind.OpenParenToken),
SyntaxList<SeparatedElement<FunctionParameter>>.Empty(),
CreateMissingToken(SyntaxKind.CloseParenToken)),
new FunctionBody(
CreateMissingToken(SyntaxKind.OpenBraceToken),
SyntaxList<SeparatedElement<Statement>>.Empty(),
null,
null,
CreateMissingToken(SyntaxKind.CloseBraceToken))));
var KustoFunctionBody =
new ParserInfo(
parser: queryParser.FunctionBody.Cast<SyntaxElement>(),
element: new CustomElementDescriptor(hint: Editor.CompletionHint.Syntax),
missing: () => new FunctionBody(
CreateMissingToken(SyntaxKind.OpenBraceToken),
SyntaxList<SeparatedElement<Statement>>.Empty(),
null,
null,
CreateMissingToken(SyntaxKind.CloseBraceToken)));
var CommandInput =
First(
If(Token(SyntaxKind.DotToken),
command.Cast<SyntaxElement>()),
queryParser.StatementList.Cast<SyntaxElement>());
var KustoCommandInputInfo =
new ParserInfo(
CommandInput,
new CustomElementDescriptor(CompletionHint.Tabular),
() => (SyntaxElement)Q.MissingExpression());
var InputTextTokens = ZeroOrMore(AnyTokenButEnd);
SourceProducer<LexicalToken, SyntaxToken> InputTextBuilder = (source, start, length) =>
{
if (length > 0)
{
var builder = new StringBuilder();
var token = source.Peek(start);
var trivia = token.Trivia;
builder.Append(source.Peek(start).Text);
for (int i = 1; i < length; i++)
{
token = source.Peek(start + i);
builder.Append(token.Trivia);
builder.Append(token.Text);
}
return SyntaxToken.Other(trivia, builder.ToString(), SyntaxKind.InputTextToken);
}
else
{
return SyntaxToken.Other("", "", SyntaxKind.InputTextToken);
}
};
var InputText =
Convert(InputTextTokens, InputTextBuilder);
var KustoInputText =
new ParserInfo(
InputText.Cast<SyntaxElement>(),
new CustomElementDescriptor(CompletionHint.None),
() => (SyntaxElement)SyntaxToken.Other("", "", SyntaxKind.InputTextToken));
var BracketedInputTextTokens =
ZeroOrMore(Not(Token("]")));
var BracketedInputText =
Convert(BracketedInputTextTokens, InputTextBuilder);
var KustoBracketedInputText =
new ParserInfo(
BracketedInputText.Cast<SyntaxElement>(),
new CustomElementDescriptor(CompletionHint.None),
() => (SyntaxElement)SyntaxToken.Other("", "", SyntaxKind.InputTextToken));
return new Dictionary<string, ParserInfo>()
{
{ "value", KustoValueInfo },
{ "timespan", KustoValueInfo },
{ "datetime", KustoValueInfo },
{ "string", KustoStringLiteralInfo },
{ "bracketed_string", KustoBracketedStringLiteralInfo },
{ "bool", KustoValueInfo },
{ "long", KustoValueInfo },
{ "int", KustoValueInfo },
{ "decimal", KustoValueInfo },
{ "real", KustoValueInfo },
{ "type", KustoTypeInfo },
{ "guid", KustoGuidLiteralInfo },
{ "name", KustoNameDeclarationInfo },
{ "wildcarded_name", KustoWildcardedNameDeclarationInfo },
{ "qualified_wildcarded_name", KustoQualifiedWildcardedNameDeclarationInfo },
{ "column", KustoColumnNameInfo },
{ "table_column", KustoTableColumnNameInfo },
{ "database_table_column", KustoDatabaseTableColumnNameInfo },
{ "table", KustoTableNameInfo },
{ "externaltable", KustoExternalTableNameInfo },
{ "materializedview", KustoMaterializedViewNameInfo },
{ "database_table", KustoDatabaseTableNameInfo },
{ "database", KustoDatabaseNameInfo },
{ "cluster", KustoClusterNameInfo },
{ "function", KustoFunctionNameInfo },
{ "function_declaration", KustoFunctionDeclaration },
{ "function_body", KustoFunctionBody },
{ "input_query", KustoCommandInputInfo },
{ "input_data", KustoInputText },
{ "bracketed_input_data", KustoBracketedInputText }
};
}