예제 #1
0
            private void AssociateToProviderFunction(string providerFunctionName, IFunctionExpression factoryFunction)
            {
                var constructedFactoryType     = factoryFunction.GetJsType(context, new JsCyclicFlowAccumulator()).GetConstructedType(JsUnresolvedTypeArray.NoList);
                var providerFunctionGlobalType = GetProviderFunctionGlobalType(providerFunctionName);
                var offset = context.GetDocumentStartOffset(factoryFunction);

                CreateAssignmentAssociation(providerFunctionGlobalType, constructedFactoryType, offset);
            }
예제 #2
0
            private void AssociateToProviderGet(string providerFunctionName, IFunctionExpression providerGetFactoryFunction)
            {
                var serviceType           = providerGetFactoryFunction.GetJsType(context, new JsCyclicFlowAccumulator()).GetReturnType();
                var providerGetGlobalType = GetProviderGetGlobalType(providerFunctionName);
                var offset = context.GetDocumentStartOffset(providerGetFactoryFunction);

                CreateAssignmentAssociation(providerGetGlobalType, serviceType, offset);
            }
예제 #3
0
        private object Act(IFunctionExpression expression,
                           IFunctionParametersFiller functionParametersFiller = null,
                           IFunctionHandlerResolver functionHandlerResolver   = null)
        {
            var executor = new FunctionExpressionExecutor(functionParametersFiller ?? Substitute.For <IFunctionParametersFiller>(),
                                                          functionHandlerResolver ?? Substitute.For <IFunctionHandlerResolver>());

            return(executor.Execute(expression));
        }
예제 #4
0
        private ILiteralBinaryFunctionExpression <T, U> get <T, U>(IBinaryFunctionExpression <T, U> expression, IEvaluator ev, IContext context)
        {
            IFunctionExpression <T, U> ex = expression;

            while (!ex.IsLiteral)
            {
                ex = ex.Evaluate(this, context);
            }
            return(ex as ILiteralBinaryFunctionExpression <T, U>);
        }
예제 #5
0
            private void ProcessServiceInjection(IExpressionOrSpread owner, IFunctionExpression factoryFunction)
            {
                var injectedServiceNames = GetInjectedServiceNames(owner, factoryFunction);

                for (var i = 0; i < factoryFunction.Parameters.Count; i++)
                {
                    var parameter   = factoryFunction.Parameters[i];
                    var serviceName = injectedServiceNames[i];

                    AssociateToParameter(serviceName, parameter);
                }
            }
예제 #6
0
            private void ProcessModuleProviderRegistration(string serviceName, IFunctionExpression factoryFunction)
            {
                if (factoryFunction == null)
                {
                    return;
                }

                // The function is likely to be anonymous, in which case, create a default name
                var providerName = factoryFunction.HasName ? factoryFunction.DeclaredName : serviceName + ProviderSuffix;

                AssociateToProviderGlobalType(serviceName, providerName, factoryFunction);
                AssociateToServiceGlobalType(serviceName, providerName, factoryFunction);
            }
예제 #7
0
            private void ProcessModuleFactoryRegistration(string serviceName, IFunctionExpression factoryFunction)
            {
                if (factoryFunction == null)
                {
                    return;
                }

                // The return type of the factory function
                var serviceType   = factoryFunction.GetFunctionImplicitReturnType(context);
                var serviceOffset = context.GetDocumentStartOffset(factoryFunction);

                AssociateToServiceGlobalType(serviceName, serviceType, serviceOffset);
            }
예제 #8
0
            private void ProcessModuleServiceRegistration(string serviceName, IFunctionExpression factoryFunction)
            {
                if (factoryFunction == null)
                {
                    return;
                }

                // The factory function is a constructor, use the constructed type
                var serviceType   = factoryFunction.GetJsType(context, new JsCyclicFlowAccumulator()).GetConstructedType(JsUnresolvedTypeArray.NoList);
                var serviceOffset = context.GetDocumentStartOffset(factoryFunction);

                AssociateToServiceGlobalType(serviceName, serviceType, serviceOffset);
            }
예제 #9
0
        public object Execute(IFunctionExpression expression)
        {
            var functionType = expression.FunctionType;
            var functionDefinitionImplementation = functionType.GetGenericInterfaceDefinitionImplementation(typeof(IFunction <>));
            var resultType = functionDefinitionImplementation.GetGenericArguments()[0];

            try
            {
                return(_executeFunctionMethod.Value
                       .MakeGenericMethod(functionType, resultType)
                       .Invoke(this,
                               new object[] { expression.ArgumentExpressions }));
            }
            catch (TargetInvocationException exception)
            {
                throw exception.InnerException;
            }
        }
예제 #10
0
            private string[] GetInjectedServiceNames(IExpressionOrSpread owner, IFunctionExpression factoryFunction)
            {
                // TODO: Get the names from the $inject string literal array
                var injectedServiceNames = factoryFunction.Parameters.Select(p => p.GetDeclaredName()).ToArray();

                var arrayLiteral = owner as IArrayLiteral;

                if (arrayLiteral != null)
                {
                    for (int i = 0; i < injectedServiceNames.Length && i < arrayLiteral.ArrayElements.Count; i++)
                    {
                        var serviceName = arrayLiteral.ArrayElements[i].GetStringLiteralValue();
                        if (!string.IsNullOrEmpty(serviceName))
                        {
                            injectedServiceNames[i] = serviceName;
                        }
                    }
                }

                return(injectedServiceNames);
            }
예제 #11
0
            private void ProcessProviderFunctionDeclaration(string providerFunctionName, IFunctionExpression functionExpression)
            {
                if (!providerFunctionName.EndsWith(ProviderSuffix))
                {
                    return;
                }

                var block = functionExpression.Block;

                if (block == null)
                {
                    return;
                }

                IFunctionExpression providerGetFactoryFunction = null;

                foreach (var statement in block.StatementsEnumerable.OfType <IExpressionStatement>())
                {
                    var assignment = statement.Expression.LastExpression as ISimpleAssignmentExpression;
                    if (assignment == null)
                    {
                        continue;
                    }

                    if (IsAssignmentToGet(assignment))
                    {
                        providerGetFactoryFunction = GetFactoryFunction(assignment.Source);
                        if (providerGetFactoryFunction != null)
                        {
                            break;
                        }
                    }
                }

                if (providerGetFactoryFunction != null)
                {
                    AssociateToProviderGet(providerFunctionName, providerGetFactoryFunction);
                }
            }
 public override void VisitFunctionExpression(IFunctionExpression functionExpression)
 {
     ProcessProviderFunctionDeclaration(functionExpression);
     base.VisitFunctionExpression(functionExpression);
 }
 private void AssociateToProviderGet(string providerFunctionName, IFunctionExpression providerGetFactoryFunction)
 {
     var serviceType = providerGetFactoryFunction.GetJsType(context).GetReturnType();
     var providerGetGlobalType = GetProviderGetGlobalType(providerFunctionName);
     var offset = context.GetDocumentStartOffset(providerGetFactoryFunction);
     CreateAssignmentAssociation(providerGetGlobalType, serviceType, offset);
 }
            private string[] GetInjectedServiceNames(IExpressionOrSpread owner, IFunctionExpression factoryFunction)
            {
                // TODO: Get the names from the $inject string literal array
                var injectedServiceNames = factoryFunction.Parameters.Select(p => p.GetDeclaredName()).ToArray();

                var arrayLiteral = owner as IArrayLiteral;
                if (arrayLiteral != null)
                {
                    for (int i = 0; i < injectedServiceNames.Length && i < arrayLiteral.ArrayElements.Count; i++)
                    {
                        var serviceName = arrayLiteral.ArrayElements[i].GetStringLiteralValue();
                        if (!string.IsNullOrEmpty(serviceName))
                            injectedServiceNames[i] = serviceName;
                    }
                }

                return injectedServiceNames;
            }
예제 #15
0
 // Built in services
 // Sets up the type for an injected factory function (type of the last parameter
 // to the array literal assigned to $get)
 // function $BrowserProvider() {
 //   this.$get = [ '$window', '$log', ..., function($window, $log, ...) { ...
 private void ProcessProviderFunctionDeclaration(IFunctionExpression functionExpression)
 {
     ProcessProviderFunctionDeclaration(functionExpression.DeclaredName, functionExpression);
 }
            private void ProcessModuleFactoryRegistration(string serviceName, IFunctionExpression factoryFunction)
            {
                if (factoryFunction == null)
                    return;

                // The return type of the factory function
                var serviceType = factoryFunction.GetFunctionImplicitReturnType(context);
                var serviceOffset = context.GetDocumentStartOffset(factoryFunction);
                AssociateToServiceGlobalType(serviceName, serviceType, serviceOffset);
            }
            private void ProcessModuleServiceRegistration(string serviceName, IFunctionExpression factoryFunction)
            {
                if (factoryFunction == null)
                    return;

                // The factory function is a constructor, use the constructed type
                // TODO: Is this right? What invocation info should I use?
                var serviceType = factoryFunction.GetJsType(context).GetConstructedType(JsUnresolvedTypeArray.EmptyList);
                var serviceOffset = context.GetDocumentStartOffset(factoryFunction);
                AssociateToServiceGlobalType(serviceName, serviceType, serviceOffset);
            }
            private void ProcessModuleProviderRegistration(string serviceName, IFunctionExpression factoryFunction)
            {
                if (factoryFunction == null)
                    return;

                // The function is likely to be anonymous, in which case, create a default name
                var providerName = factoryFunction.HasName ? factoryFunction.DeclaredName : serviceName + ProviderSuffix;

                AssociateToProviderGlobalType(serviceName, providerName, factoryFunction);
                AssociateToServiceGlobalType(serviceName, providerName, factoryFunction);
            }
 // Built in services
 // Sets up the type for an injected factory function (type of the last parameter
 // to the array literal assigned to $get)
 // function $BrowserProvider() {
 //   this.$get = [ '$window', '$log', ..., function($window, $log, ...) { ...
 private void ProcessProviderFunctionDeclaration(IFunctionExpression functionExpression)
 {
     ProcessProviderFunctionDeclaration(functionExpression.DeclaredName, functionExpression);
 }
예제 #20
0
 public override void VisitFunctionExpression(IFunctionExpression functionExpression)
 {
     ProcessProviderFunctionDeclaration(functionExpression);
     base.VisitFunctionExpression(functionExpression);
 }
 private void AssociateToProviderFunction(string providerFunctionName, IFunctionExpression factoryFunction)
 {
     var constructedFactoryType = factoryFunction.GetJsType(context).GetConstructedType(JsUnresolvedTypeArray.EmptyList);
     var providerFunctionGlobalType = GetProviderFunctionGlobalType(providerFunctionName);
     var offset = context.GetDocumentStartOffset(factoryFunction);
     CreateAssignmentAssociation(providerFunctionGlobalType, constructedFactoryType, offset);
 }
            private void ProcessProviderFunctionDeclaration(string providerFunctionName, IFunctionExpression functionExpression)
            {
                if (!providerFunctionName.EndsWith(ProviderSuffix))
                    return;

                var block = functionExpression.Block;
                if (block == null)
                    return;

                IFunctionExpression providerGetFactoryFunction = null;
                foreach (var statement in block.StatementsEnumerable.OfType<IExpressionStatement>())
                {
                    var assignment = statement.Expression.LastExpression as ISimpleAssignmentExpression;
                    if (assignment == null)
                        continue;

                    if (IsAssignmentToGet(assignment))
                    {
                        providerGetFactoryFunction = GetFactoryFunction(assignment.Source);
                        if (providerGetFactoryFunction != null)
                            break;
                    }
                }

                if (providerGetFactoryFunction != null)
                    AssociateToProviderGet(providerFunctionName, providerGetFactoryFunction);
            }
            private void ProcessServiceInjection(IExpressionOrSpread owner, IFunctionExpression factoryFunction)
            {
                var injectedServiceNames = GetInjectedServiceNames(owner, factoryFunction);

                for (var i = 0; i < factoryFunction.Parameters.Count; i++)
                {
                    var parameter = factoryFunction.Parameters[i];
                    var serviceName = injectedServiceNames[i];

                    AssociateToParameter(serviceName, parameter);
                }
            }