示例#1
0
        public void GetRequiredNamespaces()
        {
            // Arrange
            var model  = this.Calculator.Semantic;
            var method = this.Calculator.AddComplexMethod;

            var parameterTypes = SyntaxNodeUtility.TryGetParameters(model, method, out List <TypedParameter> typedParameters);
            var usedTypes      = typedParameters.Select(p => p.Type).ToList();

            // Act
            var result = SyntaxNodeUtility.TryGetRequiredNamespaces(model, usedTypes, out HashSet <string> requiredNamespaces);

            // Assert
            Assert.True(result);
            Assert.Single(requiredNamespaces);
            Assert.Equal("WebJobs.Extensions.DurableTask.CodeGen.Example.Models", requiredNamespaces.First());
        }
        public static bool TryParse(SemanticModel model, MethodDeclarationSyntax method, out DurableFunction function)
        {
            function = null;

            if (!SyntaxNodeUtility.TryGetFunctionName(model, method, out string name))
            {
                return(false);
            }

            if (!SyntaxNodeUtility.TryGetFunctionKind(method, out DurableFunctionKind kind))
            {
                return(false);
            }

            if (!SyntaxNodeUtility.TryGetReturnType(method, out TypeSyntax returnType))
            {
                return(false);
            }

            if (!SyntaxNodeUtility.TryGetParameters(model, method, out List <TypedParameter> parameters))
            {
                return(false);
            }

            if (!SyntaxNodeUtility.TryGetQualifiedTypeName(model, method, out string fullTypeName))
            {
                return(false);
            }

            var usedTypes = new List <TypeSyntax>();

            usedTypes.Add(returnType);
            usedTypes.AddRange(parameters.Select(p => p.Type));

            if (!SyntaxNodeUtility.TryGetRequiredNamespaces(model, usedTypes, out HashSet <string> requiredNamespaces))
            {
                return(false);
            }

            requiredNamespaces.UnionWith(GetRequiredGlobalNamespaces());

            function = new DurableFunction(fullTypeName, name, kind, parameters, returnType, requiredNamespaces);
            return(true);
        }
示例#3
0
        public void GetRequiredNamespacesWithGenerics()
        {
            // Arrange
            var model  = this.Calculator.Semantic;
            var method = this.Calculator.AddListComplexMethod;

            SyntaxNodeUtility.TryGetParameters(model, method, out List <TypedParameter> typedParameters);
            var usedTypes = typedParameters.Select(p => p.Type).ToList();

            // Act
            var result = SyntaxNodeUtility.TryGetRequiredNamespaces(model, usedTypes, out HashSet <string> requiredNamespaces);

            // Assert
            Assert.True(result);
            Assert.Equal(2, requiredNamespaces.Count);
            var requiredNamespaceList = requiredNamespaces.ToList();

            Assert.Equal("System.Collections.Generic", requiredNamespaceList[0]);
            Assert.Equal("WebJobs.Extensions.DurableTask.CodeGen.Example.Models", requiredNamespaceList[1]);
        }