Пример #1
0
        public static IEnumerable <SyntaxNode> BuildFunctionRefCall(this RoslynEcsTranslator translator,
                                                                    FunctionRefCallNodeModel call, IPortModel portModel)
        {
            if (!call.Function)
            {
                yield break;
            }

            ExpressionSyntax instance = translator.BuildArgumentList(call, out var argumentList);

            if (!call.Function.IsInstanceMethod)
            {
                instance = IdentifierName(((VSGraphModel)call.Function.GraphModel).TypeName);
            }

            var invocationExpressionSyntax =
                instance == null ||
                instance is LiteralExpressionSyntax && instance.IsKind(SyntaxKind.NullLiteralExpression)
                ? InvocationExpression(IdentifierName(call.Function.CodeTitle))
                : InvocationExpression(
                    MemberAccessExpression(
                        SyntaxKind.SimpleMemberAccessExpression,
                        instance,
                        IdentifierName(call.Function.CodeTitle)));

            invocationExpressionSyntax = invocationExpressionSyntax.WithArgumentList(
                ArgumentList(SeparatedList(argumentList)));

            if (portModel == null)
            {
                yield return(ExpressionStatement(invocationExpressionSyntax).NormalizeWhitespace());
            }
            else
            {
                yield return(invocationExpressionSyntax.NormalizeWhitespace());
            }
        }
        public static IEnumerable <SyntaxNode> BuildFunctionRefCall(this RoslynTranslator translator, FunctionRefCallNodeModel call, IPortModel portModel)
        {
            if (call.Function.Destroyed)
            {
                yield break;
            }
            ExpressionSyntax instance = BuildArgumentList(translator, call, out var argumentList);

            if (!call.Function.IsInstanceMethod)
            {
                instance = SyntaxFactory.IdentifierName(((VSGraphModel)call.Function.GraphModel).TypeName);
            }
            InvocationExpressionSyntax invocationExpressionSyntax = null;

#if UNITY_EDITOR
            var instancePort = call.InstancePort;
            if (instancePort != null && instancePort.DataType.GraphModelReference != null)
            {
                var genericTypeName = call.InstancePort.DataType.Name(translator.Stencil);
                invocationExpressionSyntax = FunctionInvokeExpression(genericTypeName, call.Function.CodeTitle, instance, argumentList);
            }
#endif
            // not a VisualBehaviour reference method call
            if (invocationExpressionSyntax == null)
            {
                invocationExpressionSyntax = instance == null ||
                                             (instance is LiteralExpressionSyntax &&
                                              (instance).IsKind(SyntaxKind.NullLiteralExpression))
                    ? SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(call.Function.CodeTitle))
                    : SyntaxFactory.InvocationExpression(
                    SyntaxFactory.MemberAccessExpression(
                        SyntaxKind.SimpleMemberAccessExpression,
                        instance,
                        SyntaxFactory.IdentifierName(call.Function.CodeTitle)))
                ;

                invocationExpressionSyntax = invocationExpressionSyntax.WithArgumentList(
                    SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(argumentList)));
            }

            if (portModel == null)
            {
                yield return(SyntaxFactory.ExpressionStatement(
                                 invocationExpressionSyntax)
                             .NormalizeWhitespace());
            }
            else
            {
                yield return(invocationExpressionSyntax.NormalizeWhitespace());
            }
        }