public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
//handle language constructs
string typeName = node.ReturnType.ToString();
switch (typeName)
{
case "on": return rewriteEventHandler(node);
case "function": return rewriteFunction(node, false);
case "method": return rewriteFunction(node, true);
case "typedef": return rewriteTypedef(node);
case "":
{
switch (node.Identifier.ToString())
{
case "constructor": return rewriteConstructor(node);
}
break;
}
}
//handle dsls
IDSLHandler dsl = null;
DSLSurroundings ds = node.Parent is CompilationUnitSyntax ? DSLSurroundings.Global : DSLSurroundings.TypeBody;
string id = null;
if (!node.ReturnType.IsMissing)
{
dsl = ctx_.CreateDSL(typeName);
id = node.Identifier.ToString();
}
else
dsl = ctx_.CreateDSL(node.Identifier.ToString());
if (dsl != null)
{
DSLContext dctx = new DSLContext { MainNode = node, Surroundings = ds, Id = id, ExtraMembers = members_ };
return dsl.compile(ctx_, dctx);
}
return node.WithBody((BlockSyntax)base.Visit(node.Body));
}
private SyntaxNode rewriteInvocation(InvocationExpressionSyntax node, bool assign)
{
IDSLHandler dsl = ctx_.CreateDSL(node.Expression.ToString());
if (dsl != null)
{
DSLContext dctx = new DSLContext { MainNode = node, Surroundings = DSLSurroundings.Code, Assign = assign, ExtraMembers = members_ };
Debug.Assert(pending_ == null);
pending_ = new ResolveDSLCode(dsl, ctx_, dctx);
return dsl.compile(ctx_, dctx);
}
else if (node.ArgumentList.GetDiagnostics().Any())
{
return SyntaxFactory.InvocationExpression(node.Expression, (ArgumentListSyntax)Visit(node.ArgumentList));
}
return node;
}
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
if (node.Declaration.Variables.Count == 1)
{
IDSLHandler dsl = null;
dsl = ctx_.CreateDSL(node.Declaration.Type.ToString());
if (dsl != null)
{
if (node.Declaration.Variables.Count != 1)
{
//td: error
return node;
}
var variable = node.Declaration.Variables[0];
DSLContext dctx = new DSLContext { MainNode = variable, Surroundings = DSLSurroundings.Code, Assign = false, ExtraMembers = members_ };
Debug.Assert(pending_ == null);
pending_ = new ResolveDSLCode(dsl, ctx_, dctx);
return dsl.compile(ctx_, dctx);
}
}
return base.VisitLocalDeclarationStatement(node);
}
public SyntaxNode compile(ExcessContext ctx, DSLContext dctx)
{
setContext(_parser, ctx);
setContext(_linker, ctx);
var node = dctx.MainNode;
switch (dctx.Surroundings)
{
case DSLSurroundings.Global:
{
if (node is ClassDeclarationSyntax)
{
if (_parseClass == null)
throw new InvalidOperationException("This dsl does not support types");
var classDeclaration = (ClassDeclarationSyntax)ctx.Rewriter.Visit(node);
var id = classDeclaration.Identifier.ToString();
var result = ctx.Rewriter.Visit(node);
return (SyntaxNode)_parseClass.Invoke(_parser, new object[] { classDeclaration, id, SyntaxFactory.ParameterList() });
}
else if (node is MethodDeclarationSyntax)
{
if (_parseNamespace == null)
throw new InvalidOperationException("This dsl does not support namespaces");
var method = (MethodDeclarationSyntax)node;
var id = method.ReturnType.IsMissing? "" : method.Identifier.ToString();
var code = (BlockSyntax)ctx.Rewriter.Visit(method.Body);
return (SyntaxNode)_parseNamespace.Invoke(_parser, new object[] { method, id, method.ParameterList, code });
}
//td: error
break;
}
case DSLSurroundings.TypeBody:
{
if (_parseMethod == null)
throw new InvalidOperationException("This dsl does not support methods");
var method = (MethodDeclarationSyntax)node;
var code = (BlockSyntax)ctx.Rewriter.Visit(method.Body);
return (SyntaxNode)_parseMethod.Invoke(_parser, new object[] { method, "", method.ParameterList, code });
}
case DSLSurroundings.Code:
{
if (_parseCodeHeader == null)
return null;
return (SyntaxNode)_parseCodeHeader.Invoke(_parser, new object[] { node });
}
}
return node;
}
public SyntaxNode setCode(ExcessContext ctx, DSLContext dctx, BlockSyntax code)
{
if (_parseCode == null)
throw new InvalidOperationException("This dsl does not support code");
SyntaxNode node = dctx.MainNode;
string identifier = "";
ParameterListSyntax args = null;
var invocation = node as InvocationExpressionSyntax;
if (invocation != null)
{
args = toParameterList(invocation.ArgumentList.Arguments);
}
else
{
var varDeclarator = node as VariableDeclaratorSyntax;
if (varDeclarator == null)
{
//td: error
return node;
}
identifier = varDeclarator.Identifier.ToString();
args = toParameterList(varDeclarator.ArgumentList.Arguments);
}
code = (BlockSyntax)ctx.Rewriter.Visit(code);
return (SyntaxNode)_parseCode.Invoke(_parser, new object[] { code, identifier, args, code, dctx.Assign });
}
public ResolveDSLCode(IDSLHandler dsl, ExcessContext ctx, DSLContext dctx)
{
dsl_ = dsl;
ctx_ = ctx;
dctx_ = dctx;
}
public SyntaxNode rewrite(CSharpSyntaxRewriter transform, SyntaxNode node, out LookAheadAction action)
{
if (node is ClassDeclarationSyntax)
{
action = LookAheadAction.SUCCEDED;
ClassDeclarationSyntax clazz = (ClassDeclarationSyntax)node;
DSLContext dctx = new DSLContext { MainNode = node, Surroundings = DSLSurroundings.Global, ExtraMembers = extraMembers_ };
return dsl_.compile(ctx_, dctx);
}
action = LookAheadAction.FAILED;
return null;
}
