private static IEnumerable <MemberDeclarationSyntax> createRemoteConstructors(ClassDeclarationSyntax @class, string typeName)
{
var constructor = @class
.ChildNodes()
.OfType <ConstructorDeclarationSyntax>()
.OrderBy(ctor => ctor.ParameterList.Parameters.Count)
.FirstOrDefault();
var result = CSharp.ConstructorDeclaration(typeName)
.AddParameterListParameters(CSharp
.Parameter(CSharp.Identifier("id")).WithType(CSharp.ParseTypeName("Guid")))
.WithBody(CSharp.Block(Templates.RemoteIdAssign))
.WithModifiers(Roslyn.@public);
if (constructor != null)
{
result = result.WithInitializer(CSharp.ConstructorInitializer(
SyntaxKind.BaseConstructorInitializer,
CSharp.ArgumentList(CSharp.SeparatedList(
constructor
.ParameterList
.Parameters
.Select(parameter => CSharp.Argument(
CSharp.DefaultExpression(parameter.Type)))))));
}
return(new MemberDeclarationSyntax[]
{
result
});
}
private static MemberDeclarationSyntax GenerateConstructor(ClassDeclarationSyntax @class, IEnumerable <ParameterSyntax> parameters)
{
return(CSharp.ConstructorDeclaration(@class.Identifier)
.WithModifiers(RoslynCompiler.@public)
.AddParameterListParameters(parameters.ToArray())
.AddBodyStatements(parameters
.Select(param =>
ModelAssign.Get <StatementSyntax>(param.Identifier))
.ToArray()));
}
private static SyntaxNode addConstructor(SyntaxNode node)
{
var classDeclaration = node as ClassDeclarationSyntax;
Assert.IsTrue(classDeclaration != null);
return(classDeclaration
.AddMembers(CSharp.ConstructorDeclaration(classDeclaration.Identifier)
.WithBody(CSharp.Block())));
}
private static Func <SyntaxNode, Scope, SyntaxNode> CompileApp(Options options)
{
var compileObject = CompileObject(options);
return((node, scope) =>
{
var result = (node as ClassDeclarationSyntax)
.WithModifiers(CSharp.TokenList(
CSharp.Token(SyntaxKind.PublicKeyword)));
var main = result
.DescendantNodes()
.OfType <MethodDeclarationSyntax>()
.Where(method => method.Identifier.ToString() == "main")
.SingleOrDefault();
if (main != null)
{
result = result.ReplaceNode(main, CompileAppMain(main, options));
}
else
{
Debug.Assert(false, "concurrent app must have main"); //td: error
}
if (options.GenerateAppProgram)
{
scope.AddType(Templates.AppProgram.Get <ClassDeclarationSyntax>());
}
//convert to concurrent object
result = (ClassDeclarationSyntax)compileObject(result, scope);
//add a way for this app to run, stop and await completion
var runner = null as Func <BlockSyntax, MemberDeclarationSyntax>;
if (options.GenerateAppConstructor)
{
runner = body => CSharp.ConstructorDeclaration("__app")
.WithModifiers(CSharp.TokenList(
CSharp.Token(SyntaxKind.StaticKeyword)))
.WithBody(body);
}
else
{
runner = body => Templates.AppRun.WithBody(options.GenerateAppProgram
? CSharp.Block(new StatementSyntax[] { Templates.AppAssignArguments }
.Union(body.Statements))
: body);
}
return result.AddMembers(
runner(Templates.AppThreaded
.Get <BlockSyntax>(
Roslyn.Constant(options.ThreadCount),
Roslyn.Constant(options.BlockUntilNextEvent),
options.AsFastAsPossible
? Templates.HighPriority
: Templates.NormalPriority)),
Templates.AppArguments,
Templates.AppStop,
Templates.AppAwait);
});
}
private static SyntaxNode ProcessInjection(SyntaxNode node, Scope scope)
{
var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>();
var field = node as FieldDeclarationSyntax;
if (field == null)
{
//must be injecting on a function
var toInject = (((node as LocalDeclarationStatementSyntax)
?.Declaration
.Variables
.SingleOrDefault()
?.Initializer
?.Value as SimpleLambdaExpressionSyntax)
?.Body as BlockSyntax)
?.Statements;
if (toInject == null)
{
//td: error
return(node);
}
document.change(node.Parent, FunctionInjection(node, toInject));
return(node);
}
//otherwise, class injection
var parentClass = null as ClassDeclarationSyntax;
if (!ParseInjection(field, scope, out parentClass))
{
return(node);
}
var memberStatements = (((node as FieldDeclarationSyntax)
?.Declaration
.Variables
.SingleOrDefault()
?.Initializer
?.Value as SimpleLambdaExpressionSyntax)
?.Body as BlockSyntax)
?.Statements;
if (memberStatements == null)
{
//td: error
return(node);
}
var members = membersFromStatements(memberStatements);
document.change(parentClass, AddFields(members));
return(CSharp.ConstructorDeclaration(parentClass.Identifier)
.WithModifiers(RoslynCompiler.@public)
.WithParameterList(CSharp.ParameterList(CSharp.SeparatedList(
members
.Select(member => InjectionParameter(member)))))
.WithBody(CSharp.Block(
members
.Select(member => InjectionAssignment(member)))));
}
