private TNode ParseExtension(TNode node, Scope scope, LexicalExtension <TToken> extension)
{
var allTokens = extension.Body.ToArray();
var withoutBraces = Range(allTokens, 1, allTokens.Length - 1);
if (!withoutBraces.Any())
{
return(node);
}
var compiler = scope.GetService <TToken, TNode, TModel>();
var g = _grammar.parse(withoutBraces, scope, compiler.GetOffset(withoutBraces.First()));
if (g == null || g.Equals(default(GNode)))
{
return(node); //errors added to the scope already
}
var result = doTransform(g, scope);
if (_then != null)
{
result = _then(node, result, scope, extension);
}
return(result);
}
private static void InitApp(ServerInstance app, LexicalExtension <SyntaxToken> extension)
{
app.Id = extension.Identifier.ToString();
if (string.IsNullOrWhiteSpace(app.Id))
{
app.Id = "Default";
}
}
private Func <IEnumerable <TToken>, Scope, IEnumerable <TToken> > ReplaceExtension(string keyword, ExtensionKind kind, Func <IEnumerable <TToken>, Scope, LexicalExtension <TToken>, IEnumerable <TToken> > handler)
{
return((tokens, scope) =>
{
dynamic context = scope;
var extension = new LexicalExtension <TToken>
{
Kind = kind,
Keyword = context.keyword,
Identifier = context.id != null ? context.id : default(TToken),
Arguments = context.arguments,
Body = context.body,
};
return handler(tokens, scope, extension);
});
}
public ParserRuleContext Parse(LexicalExtension <SyntaxToken> extension, Scope scope)
{
var text = RoslynCompiler.TokensToString(extension.Body); //td: token matching
AntlrInputStream stream = new AntlrInputStream(text);
ITokenSource lexer = GetLexer(stream);
ITokenStream tokenStream = new CommonTokenStream(lexer);
Parser parser = GetParser(tokenStream);
parser.AddErrorListener(new AntlrErrors <IToken>(scope, extension.BodyStart));
var result = GetRoot(parser);
if (parser.NumberOfSyntaxErrors > 0)
{
return(null);
}
return(result);
}
private static SyntaxNode ParseDapper(SyntaxNode node, Scope scope, LexicalExtension<SyntaxToken> extension)
{
var tokenCount = extension.Body.Count();
var withoutBraces = extension
.Body
.Skip(1)
.Take(tokenCount - 2);
//generate a variable per sql statament
var connectionResolved = false;
var connectionId = default(IdentifierNameSyntax);
var connectionVariable = ParseConnection(extension.Arguments, scope, out connectionId, out connectionResolved);
var result = default(SyntaxNode);
if (node is LocalDeclarationStatementSyntax)
result = ParseQuery(node as LocalDeclarationStatementSyntax, scope, withoutBraces, connectionId);
else if (node is ExpressionStatementSyntax)
result = ParseCommand(node as ExpressionStatementSyntax, scope, withoutBraces, connectionId);
Debug.Assert(result != null); //td: error
//use the document to schedule changes in later passes
var document = scope.GetDocument<SyntaxToken, SyntaxNode, SemanticModel>();
if (connectionResolved)
{
var method = node
.Ancestors()
.FirstOrDefault(n => n is MethodDeclarationSyntax)
as MethodDeclarationSyntax;
if (method != null)
document.change(method.Body, AddConnectionVariable(connectionVariable));
return result;
}
else
//We will try to run a few known scenarios, such as the functional context
//but this must be scheduled a pass after next (when functional is ready)
return document.change(result, SkipPass(connectionId));
}
private SyntaxNode myExtSyntactical(SyntaxNode node, Scope scope, LexicalExtension <SyntaxToken> extension)
{
Assert.IsTrue(node is MethodDeclarationSyntax);
var method = node as MethodDeclarationSyntax;
Assert.IsTrue(method.Identifier.ToString() == "__extension");
var argString = RoslynCompiler.TokensToString(extension.Arguments);
Assert.IsTrue(argString == "(int i) ");
var arguments = CSharp.ParseParameterList(argString);
var codeString = RoslynCompiler.TokensToString(extension.Body);
var codeNode = CSharp.ParseStatement(codeString);
Assert.IsTrue(codeNode is BlockSyntax);
var code = codeNode as BlockSyntax;
return(method
.WithIdentifier(CSharp.ParseToken("my_ext_s"))
.WithParameterList(arguments)
.WithBody(code));
}
private TNode ParseExtension(TNode node, Scope scope, LexicalExtension <TToken> extension)
{
var allTokens = extension.Body.ToArray();
var withoutBraces = Range(allTokens, 1, allTokens.Length - 1);
if (!withoutBraces.Any())
{
return(node);
}
var compiler = scope.GetService <TToken, TNode, TModel>();
var extCopy = new LexicalExtension <TToken>
{
Kind = extension.Kind,
Keyword = extension.Keyword,
Identifier = extension.Identifier,
Arguments = extension.Arguments,
Body = withoutBraces,
BodyStart = compiler.GetOffset(withoutBraces.First()),
};
var g = _grammar.Parse(extCopy, scope);
if (g == null || g.Equals(default(GNode)))
{
return(node); //errors added to the scope already
}
var result = doTransform(g, scope);
if (_then != null)
{
result = _then(node, result, scope, extension);
}
return(result);
}
private Func <TNode, Scope, TNode> TransformLexicalExtension(LexicalExtension <TToken> extension, Func <TNode, Scope, LexicalExtension <TToken>, TNode> handler)
{
return((node, scope) => handler(node, scope, extension));
}
public GNode Parse(LexicalExtension <TToken> extension, Scope scope) => _parse(extension, scope);
private static SyntaxNode Transform(SyntaxNode oldNode, SyntaxNode newNode, Scope scope, LexicalExtension<SyntaxToken> extension)
{
Debug.Assert(newNode is BlockSyntax);
var isAssignment = oldNode is LocalDeclarationStatementSyntax;
if (!isAssignment && oldNode is BinaryExpressionSyntax)
{
var expr = oldNode as BinaryExpressionSyntax;
isAssignment = expr.Kind() == SyntaxKind.SimpleAssignmentExpression;
}
if (isAssignment)
{
scope.AddError("r01", "R does not return", oldNode);
return newNode;
}
var document = scope.GetDocument<SyntaxToken, SyntaxNode, SemanticModel>();
document.change(oldNode.Parent, RoslynCompiler.ExplodeBlock(newNode));
return newNode;
}
private static SyntaxNode Transform(SyntaxNode oldNode, SyntaxNode newNode, Scope scope, LexicalExtension <SyntaxToken> extension)
{
Debug.Assert(newNode is BlockSyntax);
var isAssignment = oldNode is LocalDeclarationStatementSyntax;
if (!isAssignment && oldNode is BinaryExpressionSyntax)
{
var expr = oldNode as BinaryExpressionSyntax;
isAssignment = expr.Kind() == SyntaxKind.SimpleAssignmentExpression;
}
if (isAssignment)
{
scope.AddError("r01", "R does not return", oldNode);
return(newNode);
}
var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>();
document.change(oldNode.Parent, RoslynCompiler.ExplodeBlock(newNode));
return(newNode);
}
private static SyntaxNode Transform(SyntaxNode oldNode, SyntaxNode newNode, Scope scope, LexicalExtension <SyntaxToken> extension)
{
Debug.Assert(newNode is AnonymousObjectCreationExpressionSyntax);
var result = createJson.Get(newNode);
var isAssignment = false;
result = Roslyn.ReplaceAssignment(oldNode, result, out isAssignment);
if (!isAssignment)
{
scope.AddError("json01", "json expects to be assigned", oldNode);
return(newNode);
}
return(result);
}
private IEnumerable <SyntaxToken> myExtLexical(IEnumerable <SyntaxToken> tokens, Scope scope, LexicalExtension <SyntaxToken> extension)
{
string testResult = "my_ext_replaced "
+ extension.Arguments != null
? RoslynCompiler.TokensToString(extension.Arguments)
: ""
+ " = "
+ RoslynCompiler.TokensToString(extension.Body);
return(RoslynCompiler.ParseTokens(testResult));
}
private SyntaxNode myExtSyntactical(SyntaxNode node, Scope scope, LexicalExtension<SyntaxToken> extension)
{
Assert.IsTrue(node is MethodDeclarationSyntax);
var method = node as MethodDeclarationSyntax;
Assert.IsTrue(method.Identifier.ToString() == "__extension");
var argString = RoslynCompiler.TokensToString(extension.Arguments);
Assert.IsTrue(argString == "(int i) ");
var arguments = CSharp.ParseParameterList(argString);
var codeString = RoslynCompiler.TokensToString(extension.Body);
var codeNode = CSharp.ParseStatement(codeString);
Assert.IsTrue(codeNode is BlockSyntax);
var code = codeNode as BlockSyntax;
return method
.WithIdentifier(CSharp.ParseToken("my_ext_s"))
.WithParameterList(arguments)
.WithBody(code);
}
private IEnumerable<SyntaxToken> myExtLexical(IEnumerable<SyntaxToken> tokens, Scope scope, LexicalExtension<SyntaxToken> extension)
{
string testResult = "my_ext_replaced "
+ RoslynCompiler.TokensToString(extension.Arguments)
+ " = "
+ RoslynCompiler.TokensToString(extension.Body);
return RoslynCompiler.ParseTokens(testResult);
}
private IEnumerable <SyntaxToken> FreeFormExtensions__Transform(IEnumerable <SyntaxToken> tokens, Scope scope, LexicalExtension <SyntaxToken> extension)
{
//must have matched starting on the first token
Assert.AreEqual("SomeExtension", tokens.First().ToString());
//must have matched the keyword correctly
Assert.AreEqual("SomeExtension", extension.Keyword.ToString());
yield return(CSharp.ParseToken("ReplacedByTransform")
.WithAdditionalAnnotations(extension
.Keyword
.GetAnnotations())); //keep original info, it is important
//add arguments
if (extension.Arguments != null && extension.Arguments.Any())
{
yield return(extension.Arguments.First());
if (!extension.Identifier.IsKind(SyntaxKind.None))
{
//add the identifier as the first parameters
yield return(extension.Identifier);
yield return(CSharp.Token(SyntaxKind.CommaToken));
}
//add the rest of the arguments, skipping types
foreach (var token in extension.Arguments)
{
if (token.IsKind(SyntaxKind.IdentifierToken))
{
yield return(token);
}
}
//close parameters
yield return(extension.Arguments.Last());
}
else
{
yield return(CSharp.Token(SyntaxKind.OpenParenToken));
if (!extension.Identifier.IsMissing)
{
//add the identifier as the first parameters
yield return(extension.Identifier);
}
yield return(CSharp.Token(SyntaxKind.CloseParenToken));
}
//add a semicolon, so it compiles
yield return(CSharp.Token(SyntaxKind.SemicolonToken));
//keep the body as is
foreach (var token in extension.Body)
{
yield return(token);
}
}
