internal override void CollectInputExpressions(List <StatementSyntax> expressions) { // Insert expressions from connected nodes base.CollectInputExpressions(expressions); // Create container variables for output parameters. // Assign correct identifiers to method call. var args = new List <SyntaxNodeOrToken>(); var parameters = m_methodInfo.GetParameters(); var index = 0; // Skip the first parameter for extension methods. if (m_methodInfo.IsDefined(typeof(ExtensionAttribute), false)) { index++; } for (; index < parameters.Length; index++) { var parameter = parameters[index]; // Create container variables for output parameters. if (parameter.IsOut) { // Output parameters var localOutputVariableName = VariableSyntaxName(parameter.Name); // add variable creation expression expressions.Add(MySyntaxFactory.LocalVariable(parameter.ParameterType.GetElementType().Signature(), localOutputVariableName)); // add variable name to parameters args.Add(SyntaxFactory.Argument( SyntaxFactory.IdentifierName(localOutputVariableName) ).WithNameColon(SyntaxFactory.NameColon(parameter.Name)) .WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword) ) ); } // Get the names of the variables supplying the values to the method call else { // Find the value input node MyTuple <MyVisualSyntaxNode, MyVariableIdentifier> inputData; if (m_parametersToInputs.TryGetValue(parameter, out inputData)) { // FOUND! // add variable name to arguments var variableName = inputData.Item1.VariableSyntaxName(inputData.Item2.VariableName); Debug.Assert(variableName != null); args.Add(SyntaxFactory.Argument( SyntaxFactory.IdentifierName( variableName ) ).WithNameColon(SyntaxFactory.NameColon(parameter.Name)) ); } else { // Not FOUND! will be probably an constant argument var paramValue = ObjectBuilder.InputParameterValues.Find(value => value.ParameterName == parameter.Name); if (paramValue == null) { // Dont panic, there could be still the default value. if (!parameter.HasDefaultValue) { // Add null / some default value args.Add( MySyntaxFactory.ConstantDefaultArgument(parameter.ParameterType) .WithNameColon(SyntaxFactory.NameColon(parameter.Name)) ); } else { // default value will take care of this continue; // no comma for you args } } else { // Add constant value to arguments args.Add(MySyntaxFactory.ConstantArgument( parameter.ParameterType.Signature(), paramValue.Value ).WithNameColon(SyntaxFactory.NameColon(parameter.Name)) ); } } } // add comma args.Add(SyntaxFactory.Token(SyntaxKind.CommaToken)); } // remove last comma if (args.Count > 0) { args.RemoveAt(args.Count - 1); } // Create the invocation syntax InvocationExpressionSyntax methodInvocation = null; if (m_methodInfo.IsStatic && !m_methodInfo.IsDefined(typeof(ExtensionAttribute))) { // Static call methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax( SyntaxFactory.IdentifierName(m_methodInfo.DeclaringType.FullName + "." + m_methodInfo.Name), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args)) ); } else { var declaringType = m_methodInfo.DeclaringType; // Non static local method invocation if (declaringType == m_scriptBaseType) { methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax( SyntaxFactory.IdentifierName(m_methodInfo.Name), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args)) ); } // Non static instance method invocation or extension method else { if (m_instance == null) { throw new Exception("FunctionNode: " + ObjectBuilder.ID + " Is missing mandatory instance input."); } var instanceVariableName = m_instance.VariableSyntaxName(ObjectBuilder.InstanceInputID.VariableName); methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax( SyntaxFactory.IdentifierName(m_methodInfo.Name), SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args)), SyntaxFactory.IdentifierName(instanceVariableName) ); } } // Finalize the syntax if (m_methodInfo.ReturnType == typeof(void)) { // just add invocation expressions.Add( SyntaxFactory.ExpressionStatement(methodInvocation) ); } else { // Create variable for return value expressions.Add( MySyntaxFactory.LocalVariable( string.Empty, VariableSyntaxName("Return"), methodInvocation ) ); } }