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 ResolveArrayArgument(ExcessContext ctx, SyntaxNode node, ArrayCreationExpressionSyntax arg)
{
ctx_ = ctx;
node_ = node;
args_.Add(SyntaxFactory.Argument(arg));
}
public ResolveEventArguments(string name, ExcessContext ctx, List <MemberDeclarationSyntax> extraMembers, SyntaxTokenList modifiers)
{
name_ = name;
ctx_ = ctx;
extraMembers_ = extraMembers;
modifiers_ = modifiers;
}
public static SyntaxTree Compile(ExcessContext ctx, string code, string file = null)
{
Compiler compiler = new Compiler(ctx);
ctx.FileName = file;
ctx.Rewriter = compiler;
SyntaxTree tree = compiler.compile(code);
bool needsRecompile = true; //td: !!!
if (needsRecompile)
{
var root = tree.GetRoot() as CompilationUnitSyntax;
if (root == null)
{
root = SyntaxFactory.CompilationUnit().
WithMembers(SyntaxFactory.List(new MemberDeclarationSyntax[] {
(MemberDeclarationSyntax)tree.GetRoot()
}));
}
var usings = ctx.GetUsings().Select <string, UsingDirectiveSyntax>(
@using => SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName(
@using)));
root = root.WithUsings(SyntaxFactory.List(usings)).
NormalizeWhitespace();
//root = root.WithUsings(SyntaxFactory.List(new UsingDirectiveSyntax[]
// {
// SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System")),
// SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Collections")),
// SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Collections.Generic")),
// })).NormalizeWhitespace();
var linkerNodes = root.GetAnnotatedNodes(Compiler.LinkerAnnotationId);
string currVersion = root.ToFullString();
root = SyntaxFactory.ParseCompilationUnit(currVersion);
foreach (var linkNode in linkerNodes)
{
SyntaxNode rn = root.FindNode(linkNode.Span);
if (rn != null)
{
var annotation = linkNode.GetAnnotations(Compiler.LinkerAnnotationId).First();
annotation = new SyntaxAnnotation(annotation.Kind, annotation.Data);
root = root.ReplaceNode(rn, rn.WithAdditionalAnnotations(annotation));
}
}
tree = root.SyntaxTree;
}
ctx.FileName = null;
return(tree);
}
public SyntaxNode link(ExcessContext ctx, SyntaxNode node, SemanticModel model)
{
if (_link == null)
{
throw new InvalidOperationException("This dsl does not support linking");
}
return((SyntaxNode)_link.Invoke(_linker, new object[] { node, model }));
}
private SyntaxNode linkArray(ExcessContext ctx, SyntaxNode linkNode, SyntaxNode newNode, SemanticModel model)
{
ArrayCreationExpressionSyntax ace = newNode as ArrayCreationExpressionSyntax;
ArgumentSyntax arg = null;
bool asParam = newNode is ArgumentSyntax;
if (asParam)
{
arg = (ArgumentSyntax)newNode;
ace = (ArrayCreationExpressionSyntax)arg.Expression;
}
ITypeSymbol arrayType = null;
foreach (var expr in ace.Initializer.Expressions)
{
ITypeSymbol type = model.GetSpeculativeTypeInfo(expr.SpanStart, expr, SpeculativeBindingOption.BindAsExpression).Type;
if (arrayType == null)
{
arrayType = type;
}
else if (type != arrayType)
{
if (isSuperClass(type, arrayType))
{
arrayType = type; //downcast
}
else if (!isSuperClass(arrayType, type))
{
//td: error
return(newNode); //unable to refine
}
}
}
if (arrayType == null)
{
return(newNode);
}
ace = ace.WithType(SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName(arrayType.Name + "[]")));
if (asParam)
{
return(arg.WithExpression(ace));
}
return(ace);
}
public static Compilation Link(ExcessContext ctx, Compilation compilation, Dictionary <SyntaxTree, SyntaxTree> track = null)
{
Compilation result = compilation;
foreach (var tree in compilation.SyntaxTrees)
{
SyntaxTree curr = ctx.fixErrors(tree, result, out result);
var linker = new Linker(ctx, result);
var resultTree = linker.link(curr.GetRoot(), out result).SyntaxTree;
if (track != null)
{
track[tree] = resultTree;
}
}
return(result);
}
public static Compilation Link(ExcessContext ctx, Compilation compilation, IEnumerable <SyntaxTree> trees, Dictionary <SyntaxTree, SyntaxTree> track = null)
{
Compilation result = compilation;
foreach (var tree in trees)
{
//add usings
var root = tree.GetRoot() as CompilationUnitSyntax;
var actualTree = root.SyntaxTree;
SyntaxTree curr = ctx.fixErrors(actualTree, result, out result);
Linker linker = new Linker(ctx, result);
var resultTree = linker.link(curr.GetRoot(), out result).SyntaxTree;
if (track != null)
{
track[tree] = resultTree;
}
}
return(result);
}
public ResolveDSLCode(IDSLHandler dsl, ExcessContext ctx, DSLContext dctx)
{
dsl_ = dsl;
ctx_ = ctx;
dctx_ = dctx;
}
public ResolveTypedef(FieldDeclarationSyntax field, ExcessContext ctx)
{
field_ = field;
ctx_ = ctx;
}
public static SyntaxTree Compile(string code, IDSLFactory factory, out ExcessContext ctx, string file = null)
{
ctx = new ExcessContext(factory);
return(Compile(ctx, code, file));
}
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 ResolveTypedFunction(FieldDeclarationSyntax field, ExcessContext ctx, bool asPublic)
{
field_ = field;
ctx_ = ctx;
asPublic_ = asPublic;
}
public ResolveDSLClass(IDSLHandler dsl, ExcessContext ctx, List <MemberDeclarationSyntax> extraMembers)
{
dsl_ = dsl;
ctx_ = ctx;
extraMembers_ = extraMembers;
}
public void SetContext(ExcessContext ctx)
{
_ctx = ctx;
_mark = new SyntaxAnnotation(ctx.GetUnique(_name));
}
public Linker(ExcessContext ctx, Compilation compilation)
{
ctx_ = ctx;
compilation_ = compilation;
}
public ExcessParamListRewriter(ExcessContext ctx)
{
ctx_ = ctx;
}
public Compiler(ExcessContext ctx)
{
ctx_ = ctx;
}
private void setContext(object obj, ExcessContext ctx)
{
var method = obj.GetType().GetMethod("SetContext");
method.Invoke(obj, new object[] { ctx });
}
