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))))); }