예제 #1
0
            protected internal override ExpressionSlim VisitParameter(ParameterExpressionSlim node)
            {
                foreach (var frame in _environment)
                {
                    if (frame.Contains(node))
                    {
                        return(node);
                    }
                }

                Globals.Add(node);

                return(node);
            }
예제 #2
0
        /// <summary>
        /// Looks up the free variable name in the Reactive metadata and attempts to unify entity types.
        /// </summary>
        /// <param name="free">The free variable.</param>
        /// <param name="metadata">The metadata to unify aginst.</param>
        /// <returns>
        /// Unifications between the free variable type and the known resource type.
        /// </returns>
        internal static IEnumerable <KeyValuePair <TypeSlim, Type> > FindAndUnify(ParameterExpressionSlim free, IReactiveMetadata metadata)
        {
            var reactiveType = ReactiveEntityTypeExtensions.FromTypeSlim(free.Type);

            if ((reactiveType & ReactiveEntityType.Func) == ReactiveEntityType.Func)
            {
                reactiveType ^= ReactiveEntityType.Func;
            }

            var metadataType = default(Type);

            switch (reactiveType)
            {
            case ReactiveEntityType.Observer:
                if (metadata.Observers.TryGetValue(new Uri(free.Name), out var observer))
                {
                    metadataType = observer.Expression.Type;
                }
                break;

            case ReactiveEntityType.Observable:
                if (metadata.Observables.TryGetValue(new Uri(free.Name), out var observable))
                {
                    metadataType = observable.Expression.Type;
                }
                break;

            case ReactiveEntityType.SubscriptionFactory:
                if (metadata.SubscriptionFactories.TryGetValue(new Uri(free.Name), out var subscriptionFactory))
                {
                    metadataType = subscriptionFactory.Expression.Type;
                }
                break;

            case ReactiveEntityType.Subscription:
                if (metadata.Subscriptions.TryGetValue(new Uri(free.Name), out var subscription))
                {
                    metadataType = subscription.Expression.Type;
                }
                break;

            case ReactiveEntityType.StreamFactory:
                if (metadata.StreamFactories.TryGetValue(new Uri(free.Name), out var streamFactory))
                {
                    metadataType = streamFactory.Expression.Type;
                }
                break;

            case ReactiveEntityType.Stream:
                if (metadata.Streams.TryGetValue(new Uri(free.Name), out var stream))
                {
                    metadataType = stream.Expression.Type;
                }
                break;
            }

            if (metadataType != null)
            {
                var unifier = new DataModelTypeUnifier();
                if (unifier.Unify(metadataType, free.Type))
                {
                    return(unifier.Entries);
                }
            }

            return(Array.Empty <KeyValuePair <TypeSlim, Type> >());
        }