RiSE4fun Code for Seal

Seal/tG

using System;
class Test {
    Test f;
    String g;
public static Test param;
    public void ImpureMethod(){       
        var x = param.f;
        x.g = "Hello";
    }            
}

Seal/Z

using System;
using System.Collections.Generic;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        List<Test> l = new List<Test>();
        l.Add(param);

    }            
}

Seal/T

using System;
using System.Collections.Generic;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        List<Test> l = new List<Test>();
        l.Add(param);
    }            
}

Seal/sz

Could not find sample or program http584747rise4fun.com47images47logo_msr_small.png

Seal/mo

WZYIDq  <a href="http://uhzzapgzpklr.com/">uhzzapgzpklr</a>, [url=http://zhdhhwsyzdqj.com/]zhdhhwsyzdqj[/url], [link=http://rrqmajzmxwaf.com/]rrqmajzmxwaf[/link], http://zhfxwvwbbjwv.com/

Seal/mn

using System;
class TestInstanceDelegates{
    TestInstanceDelegates f = null;        

    void foo(System.Func<TestInstanceDelegates, int> del){
        del(this);
    }

    public void start(TestInstanceDelegates testDel1, TestInstanceDelegates testDel2){            
        testDel1.foo((TestInstanceDelegates param) =>
        {
            testDel2.f = new TestInstanceDelegates();
            param.f = testDel2.f;
            return 0;
        });
    }
}

Seal/mG

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {

        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return WaitAndGetResult(request.Task, cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(new Task<T>(()=> result), CancellationToken.None);

                return result;
            }
        }
        
        private T WaitAndGetResult(Task<T> task, CancellationToken cancellationToken)
        {
          task.Wait(cancellationToken);
          return task.Result;
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.


                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }

            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? new List<Request>() as IEnumerable<Request>;
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {

        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
{
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {

            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/mf

using System;
class Test {
    private int f = 0;     
    public void C(Test inst3){                                     
        A(new Test());
        //var temp = inst3.foo();
        //temp.f = 3;
    }        
    public void A(Test inst){
        inst.f = 1;
    }        
    public Test foo(){
        return this;
    }
}

Seal/g

using System;
using System.Collections.Generic;
using System.Linq;

public class LinqTest
{
    int f;
    public void foo(LinqTest param){
     List<int> l = new List<int>();
   
    }
}

Seal/Fy

using System;
using System.Collections.Generic;
using System.Linq;

public class LinqTest
{
    int f;
    public void foo(LinqTest param){
        var col = from i in IntegerGenerator(param)
                  select i;
        foreach (var y in col)
        {
            y.f = 1;
        }
    }

    private IEnumerable<LinqTest> IntegerGenerator(LinqTest r) {
        yield return r;
    }
}

Seal/FS

He could say such sweet things in beetewn the coughs and as much as I wanted to ease him, still the wind grew colder around us. The dying of the season, ran its' claws over us while raking him far more menacingly. Snow fell at first white and fluffy, to which he dropped something of his own, red and wet. Fluttering slowly, dripping heavily. I can't seem to remember what came first, but now it was his blood staining my clothes, my hands. They shook so hard too, dabbling at his lips.

Seal/Fb

Все зависит как эти два браузера были открыты. Если оба через new IE ();то к ним можно обращаться через их переменные. Если они открываются по клику на какуюто линку, то можно атачиться например по свойству Find.By ( hwnd ,  значение ).А можно не париться и собрать коллекцию всех открытих IE и обрабатывать их как душе угодно например:[STAThread]static void Main (string[] args){IECollection coll = IE.InternetExplorers ();coll[0].Element (Find.ByName ( smibut1 )).Flash (5);coll[1].Element (Find.ByName ( smibut1 )).Flash (5);}

Seal/eg

Seal/c4

Could not find sample or program helloworld

Seal/C

using System;
class Test {
    //Object::Equals() method is a call-back which can potentially do anything
    public bool ConditionallyPureMethod(Object param){
        var temp = new Test();
        return param.Equals(temp);             
    }            
}

Seal/8j

using System;
public class Foo {
  int field;
  
  void Bar(Foo foo) {
    int i = 0;
    if (i != 0)
      foo.field += 1;
  }
}

Seal/8

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }

    public void Plop(Test param) {
        param.f = param;
    }
    public void Plap(Test param) {
        param.Plop(new Test());
    }
            
}

Seal/mZ

using System;
class Test {
    public Test f = null;
    public void ImpureMethod(Test param){
        var temp = new Test();
        temp.g = "Hello";    
    }            
}

Seal/0

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        Console.printLine("Hello World");
        temp.f = param;        
    }            
}

Seal/uo

Seal/uk

Наверное код можно слегка оптимизировать: <xsl:template name="loop"><xsl:param name="i"/><xsl:param name="count"/><xsl:if test="$count >= $i"><option><xsl:value-of seeclt="$i"/></option><xsl:call-template name="loop"><xsl:with-param name="i" seeclt="$i + 1"/><xsl:with-param name="count" seeclt="$count"/></xsl:call-template></xsl:if></xsl:template>

Seal/UI

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Text;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = Task.FromResult(value);
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
}

Seal/XG

using System;
class Test {
    //Object::Equals() method is a call-back which can potentially do anything
    public bool ConditionallyPureMethod(Object param){
        var temp = new Test();
        return param.Equals(temp);             
    }            
}

Seal/nN

using System;
class Test {
    Test f;
    String g;
    public void ImpureMethod(Test param){              
        var x = param.f;
        while (x != null)
        {
            x.g = "Hello";
            x = x.f;
        }        
    }            
}

Seal/nM

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
        f = param;
    }            
}

Seal/NI

main(){
}

Seal/NG

using System;
class Test {
    int x = 13;
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;   
        x += 1;     
    }            
}

Seal/hKa

я бы сделал через<xsl:apply-templates mode="year"/> и еще добавил бы <xsl:param name="i" seeclt="1900"/><xsl:param name="count" seeclt="2008"/>

Seal/hk

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;
f = param;        
    }            
}

Seal/J3

Whoa, thgins just got a whole lot easier.

Seal/hE3

using System;
class Test {
    public Test f = null;
    public Test q = null;
    public void PureMethod(Test param, Test param2){
        var temp = new Test();
        temp.f = param;
        temp.q = param2;        
    }            
}

Seal/s6

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }            
}

Seal/cz

using System;
class Test {
    Test f;
    String g;
public static param;
    public void ImpureMethod(){       
        var x = param.f;
        x.g = "Hello";
    }            
}

Seal/NY

using System;
class TestInstanceDelegates{
    TestInstanceDelegates f = null;        

    void foo(System.Func<TestInstanceDelegates, int> del){
        del(this);
    }

    public void start(TestInstanceDelegates testDel1, TestInstanceDelegates testDel2){            
        testDel1.foo((TestInstanceDelegates param) =>
        {
            testDel2.f = new TestInstanceDelegates();
            param.f = testDel2.f;
            return 0;
        });
    }
}

Seal/8V

using System;
class Test {
    Test f;
    String g;
    static Test param;
    public void ImpureMethod(){       
        var x = param.f;
        x.g = "Hello";
    }            
}

Seal/SR

using System;
class Test {
    public Test f = null;
    public void ImpureMethod(Test param){
        var temp = new Test();
        param.f = temp;        
    }            
}

Seal/2C

using System;
using System.Collections.Generic;
using System.Linq;

public class LinqTest
{
    int f;
    public void foo(LinqTest param){
        var col = from i in IntegerGenerator(param)
                  select i;
        foreach (var y in col)
        {
            y.f = 1;
        }
    }

    private IEnumerable<LinqTest> IntegerGenerator(LinqTest r) {
        yield return r;
    }
}
bkj

Seal/07

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;     
        f = param;   
    }            
}

Seal/ZK

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {

        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return WaitAndGetResult(request.Task, cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(new Task<T>(()=> result), CancellationToken.None);

                return result;
            }
        }
        
        private T WaitAndGetResult(Task<T> task, CancellationToken cancellationToken)
        {
          task.Wait(cancellationToken);
          return task.Result;
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/Z1

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = Task.FromResult(value);
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
}

Seal/YWt

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Text;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = Task.FromResult(value);
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
}

Seal/QS

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/Ql

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;   
        //Console.WriteLine("Test");
        f = temp;    
    }            
}

Seal/Qf

using System;
class Test {
    public Test f = null;
    public Test PureMethod(Test param){
        var temp = new Test();
        temp = param;
        return temp;        
    }            
}

Seal/pM

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task(() => value);
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            /
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.Result;
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(new Task(()=> result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
    /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/p

using System;
public class TestHeapCloning{
    TestHeapCloning f;
    int h;
    public void foo(TestHeapCloning param){
        TestHeapCloning local1 = bar();
        TestHeapCloning local2 = bar();
        local1.f = param;
        local2.f = new TestHeapCloning();
        local2.f.h = 1;
    }
    public TestHeapCloning bar(){
        TestHeapCloning r = new TestHeapCloning();
        return r;
    }
}

Seal/plo

using System;
class Test {
    public Test f = null;
    public void ImpureMethod(Test param){
      if (2 + 2 == 4)
        param.f = null;
    }            
}

Seal/plG

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;
        return temp.f;        
    }            
}

Seal/P3

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task(()=>value);
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
    /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/KL

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;      
        param.f = null;  
    }            
}

Seal/KF

using System;
class Test {
    public Test f = null;
    public void ImpureMethod(Test param){
        var temp = new Test();
        param.f = temp;        
    }            
}

Seal/kDL

using System;
class Test {
    public Test f = null;
    public void ImpureMethod(Test param){
      int i = 0;
      if (i < 0)
        param.f = null;
    }            
}

Seal/kdH

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {

        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return WaitAndGetResult(request.Task, cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }
        
        private T WaitAndGetResult(Task<T> task, CancellationToken cancellationToken)
        {
          task.Wait(cancellationToken);
          return task.Result;
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/Ka

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestMscorlibCalls
{
    public class TestMscorlibCalls
    {
        String f = "Hello";        
        public void foo(List<String> paramList)
        {
            List<TestMscorlibCalls> l = new List<TestMscorlibCalls>();
            l.Add(this);
            foreach (var elem in l)
            {
                elem.f = "Hi";                
            }
        }

        public void bar(List<String> paramSet)
        {
            Dictionary<TestMscorlibCalls, String> d = new Dictionary<TestMscorlibCalls, string>();
            d.Add(this, this.f);
            foreach (var key in d.Keys)
            {
                key.f = "Hi";                
            }
        }

    }
}

Seal/KAo

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                gate.Release();
            }
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return WaitAndGetResult(request.Task, cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(new Task<T>(()=> result), CancellationToken.None);

                return result;
            }
        }
        
        private T WaitAndGetResult(Task<T> task, CancellationToken cancellationToken)
        {
          task.Wait(cancellationToken);
          return task.Result;
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.


                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t) => CompleteWithTask(t, computationToStart.CancellationTokenSource.Token),
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }

            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? new List<Request>() as IEnumerable<Request>;
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();


                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);

                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {

        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
{
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {

            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/k1

using System;
using System.Collections.Generic;
using System.Linq;

public class LinqTest
{
    int f;
    private void foo(LinqTest param){
        var col = from i in IntegerGenerator(param)
                  select i;
        foreach (var y in col)
        {
            y.f = 1;
        }
    }

    private IEnumerable<LinqTest> IntegerGenerator(LinqTest r) {
        yield return r;
    }
}

Seal/JY

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;   
        //Console.WriteLine("Test");
        f = temp.     
    }            
}

Seal/Gp

using System;
class TestAliasing {
    TestAliasing f = null;
    public void A() {
        TestAliasing inst2 = new TestAliasing();
        var local = B(inst2, inst2, this);
        local.f = new TestAliasing();
    }
    public TestAliasing B(TestAliasing p1, TestAliasing p2, TestAliasing p3) {
        p2.f = p3;
        return p1.f;
    }
}

Seal/gpE

using System;
class Test {
    public Test f = null;
    public Test PureMethod(Test param){
        var temp = new Test();
        temp.f = param;
        return temp.f;        
    }            
}

Seal/EZL

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }            
}

Seal/Eg4

using System;
class Test {
    public object kp = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }            
}

Seal/9u

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;  
        f = null;      
    }            
}

Seal/97

using System;

class XYZ {
    public static int add1(int x, int y) { return x+y; }
    int f1, f2;
    public static int add2(XYZ p) { return p.f1 + p.f2; }
    public void modify() { f1 = f1 + f2; }
    public void localModify() {
       XYZ temp = new XYZ();
       temp.modify();
    }
}

Seal/95

using System;
class Test {
    public Test f = null;
    public void ImpureMethod(Test param){
      int i = 0;
      while (i < 100) {
        ++i;
      }
      if (i < 0) {
        param.f = null;
      }
    }            
}

Seal/7

using System;
class Test {
    private int f = 0;     
    public void C(Test inst3){                                     
        A(new Test());
        var temp = inst3.foo();
        temp.f = 3;
    }        
    public void A(Test inst){
        inst.f = 1;
    }        
    public Test foo(){
        return this;
    }
}

Seal/7x

using System;

class XYZ {
    public static int add1(int x, int y) { return x+y; }
    int f1, f2;
    public int add2() { return f1+f2; }
    public void modify() { f1 = f1 + f2; }
    public void localModify() {
       XYZ temp = new XYZ();
       temp.modify();
    }
}

Seal/7G

using System;
class Test {
    public Test f = null;
    public void ImpureMethod(Test param){
        Console.Write("r");    
    }            
}

Seal/77

using System;
public class Foo {
  int field;
  
  void Bar(Foo foo) {
    int i = 2 + 2;
    if (i != 4)
      foo.field += 1;
  }
}

Seal/68

using System;

class XYZ {
    public static int add1(int x, int y) { return x+y; }
    int f1, f2;
    public static int add2(XYZ p) { return p.f1 + p.f2; }
    public static void modify(XYZ p) { p.f1 = p.f1 + p.f2; }
    public void localModify() {
       XYZ temp = new XYZ();
       modify(temp);
    }
}

Seal/5E

using System.Collections.Generic;
using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace GameOfLife.Model
{
    /// <summary>
    /// Interface contract for a cell.
    /// </summary>
    public interface ICell
    {
        /// <summary>
        /// Determines whether cell is alive or not.
        /// </summary>
        bool? IsAlive { get; set; }

        /// <summary>
        /// List of all neighbours of the cell.
        /// </summary>
        IList<ICell> Neighbours { get; }
    }
}


namespace GameOfLife.Model
{
    /// <summary>
    /// Provides methods to manage the life of cells.
    /// </summary>
    static class CellLifeManager
    {
        #region Public methods

        /// <summary>
        /// Calculates and assigns the neighbours for the given collection of cells.
        /// <para><remarks>The algorithmic complexity of the method is O(n^2).</remarks></para>
        /// </summary>
        /// <param name="theCellCollection">The read-only collection of the cells.</param>
        /// <param name="theTotalColumns">Total no. of columns in which cells are arranged.</param>
        public static void SetNeighbours(ReadOnlyCollection<ICell> theCellCollection, int theTotalColumns)
        {
            for (int aCount = 0; aCount < theCellCollection.Count; aCount++)
            {
                ICell aCell = theCellCollection[aCount];
                bool aIsFirstColumnCell = aCount % theTotalColumns == 0;
                bool aIsLastColumnCell = (aCount + 1) % theTotalColumns == 0;
                IEnumerable<int> aNeighbourIndex;
                if (aIsFirstColumnCell)
                {
                    aNeighbourIndex = TraverseFullAntiClockWise(aCount, theTotalColumns)
                        .Where(T => (T >= 0 && T < theCellCollection.Count &&
                            (T != aCount + theTotalColumns - 1) && (T != aCount - theTotalColumns - 1)
                            && (T != aCount - 1)));
                }
                else if (aIsLastColumnCell)
                {
                    aNeighbourIndex = TraverseFullAntiClockWise(aCount, theTotalColumns)
                       .Where(T => (T >= 0 && T < theCellCollection.Count &&
                           (T != aCount + theTotalColumns + 1) && (T != aCount - theTotalColumns + 1)
                           && (T != aCount + 1)));
                }
                else
                {
                    aNeighbourIndex = TraverseFullAntiClockWise(aCount, theTotalColumns)
                    .Where(T => (T >= 0 && T < theCellCollection.Count));
                }
                aCell.Neighbours.Clear();
                foreach (int aIndex in aNeighbourIndex)
                {
                    aCell.Neighbours.Add(theCellCollection[aIndex]);
                }
            }
        }

        /// <summary>
        /// Sets  the alive status of the cells based on following rules :
        /// <para></para>
        /// <para></para>
        /// <para></para>
        /// <para><remarks>The algorithmic complexity of the method is O(n).</remarks></para>
        /// </summary>
        /// <param name="theCellCollection">The readonly collection of the cells.</param>
        public static void SetAliveStatus(ReadOnlyCollection<ICell> theCellCollection)
        {
            int aFinalCount = theCellCollection.Count;
            IList<bool> aIsAliveList = new List<bool>().PopulateDefaultValues(aFinalCount, false);

            for (int i = 0; i < aFinalCount; i++)
            {
                aIsAliveList[i] = ShouldBeAlive(theCellCollection[i]);
            }

            for (int i = 0; i < aFinalCount; i++)
            {
                theCellCollection[i].IsAlive = null;
                theCellCollection[i].IsAlive = aIsAliveList[i];
            }
        }
        /// <summary>
        /// Makes the alive status of all cells to be indeterminate. Value is <see cref="System.Null"/>
        /// </summary>
        /// <param name="theCellCollection">The read-only collection of the cells.</param>
        public static void ResetCellAliveStatus(ReadOnlyCollection<ICell> theCellCollection)
        {
            foreach (ICell aCell in theCellCollection)
            {
                aCell.IsAlive = null;
            }
        }

        #endregion

        #region Private methods

        /// <summary>
        /// Generates a list of all possible neighbours for a particular cell based upon the cells position.
        /// Calculation is made starting from top , traversing in anti-clockwise direction.
        /// </summary>
        /// <param name="theIndex">The zero based position of the cell in the grid.</param>
        /// <param name="theTotalColumns">Total no. of columns in which cells are arranged.</param>
        /// <returns>List{int} containing all possible neighbours list.</returns>
        private static List<int> TraverseFullAntiClockWise(int theIndex, int theTotalColumns)
        {
            return new List<int>()
            {
                theIndex + theTotalColumns - 1,
                theIndex + theTotalColumns,
                theIndex + theTotalColumns + 1,
                theIndex + 1,
                theIndex - theTotalColumns + 1,
                theIndex - theTotalColumns,
                theIndex - theTotalColumns - 1,
                theIndex - 1
            };
        }

        /// <summary>
        /// Determines whether a cell should be alive or not.
        /// </summary>
        /// <param name="theCell">The cell which alive status has to be determined.</param>
        /// <returns>True if alive or vice versa.</returns>
        private static bool ShouldBeAlive(ICell theCell)
        {
            bool aIsAlive = theCell.IsAlive.HasValue && theCell.IsAlive.Value;
            int aAliveNeighboursCount = theCell.Neighbours.Where(T => T.IsAlive.HasValue && T.IsAlive.Value).Count();
            if ((aIsAlive && (aAliveNeighboursCount == 2 || aAliveNeighboursCount == 3))
                || (aAliveNeighboursCount == 3 && !aIsAlive))
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// Extension method to create a boolean list of specified count with specified default value.
        /// </summary>
        /// <param name="theList">The list to be populated.</param>
        /// <param name="theFinalCount">Total no of elements to be added.</param>
        /// <param name="theDefaultValue">Default value for the element.</param>
        /// <returns></returns>
        private static IList<bool> PopulateDefaultValues(this IList<bool> theList, int theFinalCount, bool theDefaultValue)
        {
            for (int i = 0; i < theFinalCount; i++)
            {
                theList.Add(theDefaultValue);
            }
            return theList;
        }
        #endregion
    }
}

Seal/4rT

using System;

class XYZ {
    public static int add1(int x, int y) { return x+y; }
    int f1, f2;
    public int add2() { return f1+f2; }
    public void modify() { f1 = f1 + f2; }
    public void localModify() {
       XYZ temp = new XYZ();
       temp.modify();
    }
}

Seal/4Rf

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/2t

using System;
class Test {
    public Test f = null;
    public int kp = 0;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }            
}

Seal/1X5

using System;

class XYZ {

    public static int add1(int x, int y) { return x+y; }

    int f1, f2;

    public int add2() { return f1+f2; }

    public void modify() { f1 = f1 + f2; }

    public void localModify() {
       XYZ temp = new XYZ();
       temp.modify();
    }
  
}

Seal/1l

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {

        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/0q

using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace GameOfLife.Model
{
    /// <summary>
    /// Provides methods to manage the life of cells.
    /// </summary>
    static class CellLifeManager
    {
        #region Public methods

        /// <summary>
        /// Calculates and assigns the neighbours for the given collection of cells.
        /// <para><remarks>The algorithmic complexity of the method is O(n^2).</remarks></para>
        /// </summary>
        /// <param name="theCellCollection">The read-only collection of the cells.</param>
        /// <param name="theTotalColumns">Total no. of columns in which cells are arranged.</param>
        public static void SetNeighbours(ReadOnlyCollection<ICell> theCellCollection, int theTotalColumns)
        {
            for (int aCount = 0; aCount < theCellCollection.Count; aCount++)
            {
                ICell aCell = theCellCollection[aCount];
                bool aIsFirstColumnCell = aCount % theTotalColumns == 0;
                bool aIsLastColumnCell = (aCount + 1) % theTotalColumns == 0;
                IEnumerable<int> aNeighbourIndex;
                if (aIsFirstColumnCell)
                {
                    aNeighbourIndex = TraverseFullAntiClockWise(aCount, theTotalColumns)
                        .Where(T => (T >= 0 && T < theCellCollection.Count &&
                            (T != aCount + theTotalColumns - 1) && (T != aCount - theTotalColumns - 1)
                            && (T != aCount - 1)));
                }
                else if (aIsLastColumnCell)
                {
                    aNeighbourIndex = TraverseFullAntiClockWise(aCount, theTotalColumns)
                       .Where(T => (T >= 0 && T < theCellCollection.Count &&
                           (T != aCount + theTotalColumns + 1) && (T != aCount - theTotalColumns + 1)
                           && (T != aCount + 1)));
                }
                else
                {
                    aNeighbourIndex = TraverseFullAntiClockWise(aCount, theTotalColumns)
                    .Where(T => (T >= 0 && T < theCellCollection.Count));
                }
                aCell.Neighbours.Clear();
                foreach (int aIndex in aNeighbourIndex)
                {
                    aCell.Neighbours.Add(theCellCollection[aIndex]);
                }
            }
        }

        /// <summary>
        /// Sets  the alive status of the cells based on following rules :
        /// <para></para>
        /// <para></para>
        /// <para></para>
        /// <para><remarks>The algorithmic complexity of the method is O(n).</remarks></para>
        /// </summary>
        /// <param name="theCellCollection">The readonly collection of the cells.</param>
        public static void SetAliveStatus(ReadOnlyCollection<ICell> theCellCollection)
        {
            int aFinalCount = theCellCollection.Count;
            IList<bool> aIsAliveList = new List<bool>().PopulateDefaultValues(aFinalCount, false);

            for (int i = 0; i < aFinalCount; i++)
            {
                aIsAliveList[i] = ShouldBeAlive(theCellCollection[i]);
            }

            for (int i = 0; i < aFinalCount; i++)
            {
                theCellCollection[i].IsAlive = null;
                theCellCollection[i].IsAlive = aIsAliveList[i];
            }
        }
        /// <summary>
        /// Makes the alive status of all cells to be indeterminate. Value is <see cref="System.Null"/>
        /// </summary>
        /// <param name="theCellCollection">The read-only collection of the cells.</param>
        public static void ResetCellAliveStatus(ReadOnlyCollection<ICell> theCellCollection)
        {
            foreach (ICell aCell in theCellCollection)
            {
                aCell.IsAlive = null;
            }
        }

        #endregion

        #region Private methods

        /// <summary>
        /// Generates a list of all possible neighbours for a particular cell based upon the cells position.
        /// Calculation is made starting from top , traversing in anti-clockwise direction.
        /// </summary>
        /// <param name="theIndex">The zero based position of the cell in the grid.</param>
        /// <param name="theTotalColumns">Total no. of columns in which cells are arranged.</param>
        /// <returns>List{int} containing all possible neighbours list.</returns>
        private static List<int> TraverseFullAntiClockWise(int theIndex, int theTotalColumns)
        {
            return new List<int>()
            {
                theIndex + theTotalColumns - 1,
                theIndex + theTotalColumns,
                theIndex + theTotalColumns + 1,
                theIndex + 1,
                theIndex - theTotalColumns + 1,
                theIndex - theTotalColumns,
                theIndex - theTotalColumns - 1,
                theIndex - 1
            };
        }

        /// <summary>
        /// Determines whether a cell should be alive or not.
        /// </summary>
        /// <param name="theCell">The cell which alive status has to be determined.</param>
        /// <returns>True if alive or vice versa.</returns>
        private static bool ShouldBeAlive(ICell theCell)
        {
            bool aIsAlive = theCell.IsAlive.HasValue && theCell.IsAlive.Value;
            int aAliveNeighboursCount = theCell.Neighbours.Where(T => T.IsAlive.HasValue && T.IsAlive.Value).Count();
            if ((aIsAlive && (aAliveNeighboursCount == 2 || aAliveNeighboursCount == 3))
                || (aAliveNeighboursCount == 3 && !aIsAlive))
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// Extension method to create a boolean list of specified count with specified default value.
        /// </summary>
        /// <param name="theList">The list to be populated.</param>
        /// <param name="theFinalCount">Total no of elements to be added.</param>
        /// <param name="theDefaultValue">Default value for the element.</param>
        /// <returns></returns>
        private static IList<bool> PopulateDefaultValues(this IList<bool> theList, int theFinalCount, bool theDefaultValue)
        {
            for (int i = 0; i < theFinalCount; i++)
            {
                theList.Add(theDefaultValue);
            }
            return theList;
        }
        #endregion
    }
}

Seal/wt

using System;

class XYZ {
    public static int add1(int x, int y) { return x+y; }
    int f1, f2;
    public static int add2(XYZ p) { return p.f1 + p.f2; }
    public static void modify(XYZ p) { p.f1 = p.f1 + p.f2; }
    public void localModify() {
       XYZ temp = new XYZ();
       modify(temp);
    }
}

Seal/WL

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task(new Action(() =>value));
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/WG

aa

Seal/wD

i love travelling and lninetisg to the musici love travelling and lninetisg to the musici love travelling and lninetisg to the musicpandora jewelry pandora sale uk thomas sabo barcklets shop buy cheap online oakley sunglasses charmspandora jewelry pandora sale uk thomas sabo barcklets shop buy cheap online oakley sunglasses charmsthanks for sharing such informative and fantastic post..

Seal/P0

using System;
class Test {vbbgn h,v
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }            
}

Seal/OV

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {

        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return WaitAndGetResult(request.Task, cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(new Task<T>(()=> result), CancellationToken.None);

                return result;
            }
        }
        
        private T WaitAndGetResult(Task<T> task, CancellationToken cancellationToken)
        {
          task.Wait(cancellationToken);
          return task.Result;
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.


                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t) => CompleteWithTask(t, computationToStart.CancellationTokenSource.Token),
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }

            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? new List<Request>() as IEnumerable<Request>;
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {

        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
{
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {

            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/oP

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        //var temp = new Test();
        param.f = 1;        
    }            
}

Seal/aK

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestMscorlibCalls
{
    public class TestMscorlibCalls
    {
        String f = "Hello";        
        public void foo(List<String> paramList)
        {
            List<TestMscorlibCalls> l = new List<TestMscorlibCalls>();
            l.Add(this);
            foreach (var elem in l)
            {
                elem.f = "Hi";                
            }
        }

        public void bar(List<String> paramSet)
        {
            Dictionary<TestMscorlibCalls, String> d = new Dictionary<TestMscorlibCalls, string>();
            d.Add(this, this.f);
            foreach (var key in d.Keys)
            {
                key.f = "Hi";                
            }
        }

    }
}

Seal/j

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param
){
        var temp = new Test();
        temp.f = param;        
    }            
}

Seal/dk

using System;
using System.Collections.Generic;
using System.Linq;

public class LinqTest
{
    int f;
    public void foo(LinqTest param){
        var col = from i in IntegerGenerator(new LinqTest())
                  select i;
        foreach (var y in col)
        {
            y.f = 1;
        }
    }

    private IEnumerable<LinqTest> IntegerGenerator(LinqTest r) {
        yield return r;
    }
}

Seal/dH

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = Task.FromResult(value);
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/9D

表示英文太菜，可否把Guy的评论也稍微翻译下。。。My version of the qiotsuen starts out by restricting the input to seven letters (for Scrabble) and it was assumed you'd discard any word longer than the rack or shorter than the current best solution so a 32-bit word suffices with some finesses hinted below.Candidates who think a bitmask alone would suffice, don't understand the distinction between a bag and a set. //set俺懂，bag是啥意思？关键字眼不理解真是害死人啊。。。

Seal/2R

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        Console.write("Hello World");
        temp.f = param;        
    }            
}

Seal/0i

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        //var temp = new Test();
        param;        
    }            
}

Seal/UF

using System;
class Test {
    public Test f = 1;
    public Test q = null;
    public void PureMethod(Test param, Test param2){
        var temp = new Test();
        temp.f = param;
        temp.q = param2;        
    }            
}

Seal/u5

using System;
class XYZ {

    public static int add1(int x, int y) { return x+y; }

    int f1, f2;

    public int add2() { return f1+f2; }

         
}

Seal/u

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;  
        f=temp;      
    }            
}

Seal/Tx

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {

        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return WaitAndGetResult(request, cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }
        
        private T WaitAndGetResult(Task<T> task, CancellationToken cancellationToken)
        {
          task.Wait(cancellationToken);
          return task.Result;
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/ND

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        Console.Write(1);
        temp.f = param;        
    }            
}

Seal/hE

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        param.f = param;        
    }            
}

Seal/h1

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = new Task<T>(() => {return value;});
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {

        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return WaitAndGetResult(request.Task, cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(new Task<T>(()=> result), CancellationToken.None);

                return result;
            }
        }
        
        private T WaitAndGetResult(Task<T> task, CancellationToken cancellationToken)
        {
          task.Wait(cancellationToken);
          return task.Result;
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.


                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }

            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
     /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/h

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }            
}

Seal/d

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        Console.write(1);
        temp.f = param;        
    }            
}

Seal/HX

using System;
public class TestHeapCloning{
    TestHeapCloning f;
    int h;
    public void foo(TestHeapCloning param){
        TestHeapCloning local1 = bar();
        TestHeapCloning local2 = bar();
        local1.f = param;
        local2.f = new TestHeapCloning();
        local2.f.h = 1;
    }
    public TestHeapCloning bar(){
        TestHeapCloning r = new TestHeapCloning();
        return r;
    }
}

Seal/9

using System;
class Test {
    public Test f = null;
    private static Test g = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
        Console.WriteLine("foo");
        g = this;
    }            
}

Seal/6

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
f = param;        
    }            
}

Seal/v

using System.Collections.Generic;
using System;

Class S
{
 public void foo(List<String> paramList)
        {
            List<S> l = new List<S>();
        }
}

Seal/o

using System;
class Test {
    public Test f = null;
    public string g = "";
    public void ImpureMethod(Test param){
        var temp = new Test();
        temp.g = "Hello";    
    }            
}

Seal/Np

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        //var temp = new Test();
        Test param = new Test();      
    }            
}

Seal/ib

using System;
class Test {
    Test f;
    String g;
    static Test param;
    public void ImpureMethod(){       
        var x = .f;
        x.g = "Hello";
    }            
}

Seal/I

using System;
class Test {
    Test f;
    String g;
    public void ImpureMethod(Test param){              
        var x = param.f;
        while (x != null)
        {
            x.g = "Hello";
            x = x.f;
        }        
    }            
}

Seal/hv

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;
        temp.f = null;        
    }            
}

Seal/Da

using System;
class Test {
    public Test f = null;
    int a;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;
        param.a++;

    }            
}

Seal/d8

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }
            
}

Seal/3

Class S
{
 public void foo(List<String> paramList)
        {
            List<S> l = new List<S>();
        }
}

Seal/XK

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

namespace Roslyn.Utilities
{
    /// <summary>
    /// Represents a value that can be retrieved synchronously or asynchronously by many clients.
    /// The value will be computed on-demand the moment the first client asks for it. While being
    /// computed, more clients can request the value. As long as there are outstanding clients the
    /// underlying computation will proceed.  If all outstanding clients cancel their request then
    /// the underlying value computation will be cancelled as well.
    /// 
    /// Creators of an <see cref="AsyncLazy{T}" /> can specify whether the result of the computation is
    /// cached for future requests or not. Choosing to not cache means the computation functions are kept
    /// alive, whereas caching means the value (but not functions) are kept alive once complete.
    /// </summary>
    internal sealed class AsyncLazy<T>
    {
        /// <summary>
        /// The underlying function that starts an asynchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it.  Otherwise,
        /// it is kept around in case the value needs to be computed again.
        /// </summary>
        private Func<CancellationToken, Task<T>> asynchronousComputeFunction;

        /// <summary>
        /// The underlying function that starts an synchronous computation of the resulting value.
        /// Null'ed out once we've computed the result and we've been asked to cache it, or if we
        /// didn't get any synchronous function given to us in the first place.
        /// </summary>
        private Func<CancellationToken, T> synchronousComputeFunction;

        /// <summary>
        /// Whether or not we should keep the value around once we've computed it.
        /// </summary>
        private readonly bool cacheResult;

        /// <summary>
        /// The Task that holds the cached result.
        /// </summary>
        private Task<T> cachedResult;

        /// <summary>
        /// Mutex used to protect reading and writing to all mutable objects and fields.  Traces
        /// indicate that there's negligible contention on this lock, hence we can save some memory
        /// by using a single lock for all AsyncLazy instances.  Only trivial and non-reentrant work
        /// should be done while holding the lock.
        /// </summary>
        private static readonly NonReentrantLock gate = new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// The hash set of all currently outstanding asynchronous requests. Null if there are no requests,
        /// and will never be empty.
        /// </summary>
        private HashSet<Request> requests = null;

        /// <summary>
        /// If an asynchronous request is active, the CancellationTokenSource that allows for
        /// cancelling the underlying computation.
        /// </summary>
        private CancellationTokenSource asynchronousComputationCancellationSource = null;

        /// <summary>
        /// Whether a computation is active or queued on any thread, whether synchronous or
        /// asynchronous.
        /// </summary>
        private bool computationActive = false;

        /// <summary>
        /// Creates an AsyncLazy that always returns the value, analogous to <see cref="Task.FromResult{T}" />.
        /// </summary>
        public AsyncLazy(T value)
        {
            this.cacheResult = true;
            this.cachedResult = Task.FromResult(value);
        }

        /// <summary>
        /// Important: callers of this constructor should ensure that the compute function returns
        /// a task in a non-blocking fashion.  i.e. the function should *not* synchronously compute
        /// a value and then return it using Task.FromResult.  Instead, it should return an actual
        /// task that operates asynchronously.  If this function synchronously computes a value
        /// then that will cause locks to be held in this type for excessive periods of time.
        /// </summary>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, bool cacheResult)
            : this(asynchronousComputeFunction, synchronousComputeFunction: null, cacheResult: cacheResult)
        {
        }

        /// <summary>
        /// Creates an AsyncLazy that supports both asynchronous computation and inline synchronous
        /// computation.
        /// </summary>
        /// <param name="asynchronousComputeFunction">A function called to start the asynchronous
        /// computation. This function should be cheap and non-blocking.</param>
        /// <param name="synchronousComputeFunction">A function to do the work synchronously, which
        /// is allowed to block. This function should not be implemented by a simple Wait on the
        /// asynchronous value. If that's all you are doing, just don't pass a synchronous function
        /// in the first place.</param>
        /// <param name="cacheResult">Whether the result should be cached once the computation is
        /// complete.</param>
        public AsyncLazy(Func<CancellationToken, Task<T>> asynchronousComputeFunction, Func<CancellationToken, T> synchronousComputeFunction, bool cacheResult)
        {
            Contract.ThrowIfNull(asynchronousComputeFunction);

            this.asynchronousComputeFunction = asynchronousComputeFunction;
            this.synchronousComputeFunction = synchronousComputeFunction;
            this.cacheResult = cacheResult;
        }

        #region Lock Wrapper for Invariant Checking

        /// <summary>
        /// Takes the lock for this object and if acquired validates the invariants of this class.
        /// </summary>
        private WaitThatValidatesInvariants TakeLock(CancellationToken cancellationToken)
        {
            gate.Wait(cancellationToken);
            AssertInvariants_NoLock();
            return new WaitThatValidatesInvariants(this);
        }

        private struct WaitThatValidatesInvariants : IDisposable
        {
            private readonly AsyncLazy<T> asyncLazy;

            public WaitThatValidatesInvariants(AsyncLazy<T> asyncLazy)
            {
                this.asyncLazy = asyncLazy;
            }

            public void Dispose()
            {
                asyncLazy.AssertInvariants_NoLock();
                gate.Release();
            }
        }

        private void AssertInvariants_NoLock()
        {
            // Invariant #1: thou shalt never have an asynchronous computation running without it
            // being considered a computation
            Contract.ThrowIfTrue(this.asynchronousComputationCancellationSource != null &&
                                 !this.computationActive);

            // Invariant #2: thou shalt never waste memory holding onto empty HashSets
            Contract.ThrowIfTrue(this.requests != null &&
                                 this.requests.Count == 0);

            // Invariant #3: thou shalt never have an request if there is not
            // something trying to compute it
            Contract.ThrowIfTrue(this.requests != null &&
                                 !this.computationActive);

            // Invariant #4: thou shalt never have a cached value and any computation function
            Contract.ThrowIfTrue(this.cachedResult != null &&
                                 (this.synchronousComputeFunction != null || this.asynchronousComputeFunction != null));

            // Invariant #5: thou shalt never have a synchronous computation function but not an
            // asynchronous one
            Contract.ThrowIfTrue(this.asynchronousComputeFunction == null && this.synchronousComputeFunction != null);
        }

        #endregion

        public bool TryGetValue(out T result)
        {
            // No need to lock here since this is only a fast check to 
            // see if the result is already computed.
            if (cachedResult != null)
            {
                result = cachedResult.Result;
                return true;
            }

            result = default(T);
            return false;
        }

        public T GetValue(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            Request request = null;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult.Result;
                }

                // If there is an existing computation active, we'll just create another request
                if (computationActive)
                {
                    request = CreateNewRequest_NoLock();
                }
                else if (synchronousComputeFunction == null)
                {
                    // A synchronous request, but we have no synchronous function. Start off the async work
                    request = CreateNewRequest_NoLock();

                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
                else
                {
                    // We will do the computation here
                    this.computationActive = true;
                }
            }

            // If we simply created a new asynchronous request, so wait for it. Yes, we're blocking the thread
            // but we don't want multiple threads attempting to compute the same thing.
            if (request != null)
            {
                request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

                // Since we already registered for cancellation, it's possible that the registration has
                // cancelled this new computation if we were the only requestor.
                if (newAsynchronousComputation != null)
                {
                    StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
                }

                return request.Task.WaitAndGetResult(cancellationToken);
            }
            else
            {
                T result;

                // We are the active computation, so let's go ahead and compute.
                try
                {
                    result = synchronousComputeFunction(cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // This cancelled for some reason. We don't care why, but
                    // it means anybody else waiting for this result isn't going to get it
                    // from us.
                    using (TakeLock(CancellationToken.None))
                    {
                        this.computationActive = false;

                        if (requests != null)
                        {
                            // There's a possible improvement here: there might be another synchronous caller who
                            // also wants the value. We might consider stealing their thread rather than punting
                            // to the thread pool.
                            newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                        }
                    }

                    if (newAsynchronousComputation != null)
                    {
                        StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: null);
                    }

                    throw;
                }
                catch (Exception ex)
                {
                    // We faulted for some unknown reason. We should simply fault everything.
                    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
                    tcs.SetException(ex);
                    CompleteWithTask(tcs.Task, CancellationToken.None);

                    throw;
                }

                // We have a value, so complete
                CompleteWithTask(Task.FromResult(result), CancellationToken.None);

                return result;
            }
        }

        private Request CreateNewRequest_NoLock()
        {
            if (this.requests == null)
            {
                this.requests = new HashSet<Request>();
            }

            Request request = new Request();
            this.requests.Add(request);
            return request;
        }

        public Task<T> GetValueAsync(CancellationToken cancellationToken)
        {
            // Optimization: if we're already cancelled, do not pass go
            if (cancellationToken.IsCancellationRequested)
            {
                return new Task<T>(() => default(T), cancellationToken);
            }

            Request request;
            AsynchronousComputationToStart? newAsynchronousComputation = null;

            using (TakeLock(cancellationToken))
            {
                // If cached, get immediately
                if (cachedResult != null)
                {
                    return cachedResult;
                }

                request = CreateNewRequest_NoLock();

                // If we have either synchronous or asynchronous work current in flight, we don't need to do anything.
                // Otherwise, we shall start an asynchronous computation for this
                if (!computationActive)
                {
                    newAsynchronousComputation = RegisterAsynchronousComputation_NoLock();
                }
            }

            // We now have the request counted for, register for cancellation. It is critical this is
            // done outside the lock, as our reigstration may immediately fire and we want to avoid the
            // reentrancy
            request.RegisterForCancellation(OnAsynchronousRequestCancelled, cancellationToken);

            if (newAsynchronousComputation != null)
            {
                StartAsynchronousComputation(newAsynchronousComputation.Value, requestToCompleteSynchronously: request);
            }

            return request.Task;
        }

        private AsynchronousComputationToStart RegisterAsynchronousComputation_NoLock()
        {
            Contract.ThrowIfTrue(this.computationActive);

            this.asynchronousComputationCancellationSource = new CancellationTokenSource();
            this.computationActive = true;

            return new AsynchronousComputationToStart(this.asynchronousComputeFunction, this.asynchronousComputationCancellationSource);
        }

        private struct AsynchronousComputationToStart
        {
            public readonly Func<CancellationToken, Task<T>> AsynchronousComputeFunction;
            public readonly CancellationTokenSource CancellationTokenSource;

            public AsynchronousComputationToStart(Func<CancellationToken, Task<T>> asynchronousComputeFunction, CancellationTokenSource cancellationTokenSource)
            {
                this.AsynchronousComputeFunction = asynchronousComputeFunction;
                this.CancellationTokenSource = cancellationTokenSource;
            }
        }

        private void StartAsynchronousComputation(AsynchronousComputationToStart computationToStart, Request requestToCompleteSynchronously)
        {
            var cancellationToken = computationToStart.CancellationTokenSource.Token;

            try
            {
                cancellationToken.ThrowIfCancellationRequested();

                // DO NOT ACCESS ANY FIELDS OR STATE BEYOND THIS POINT. Since this function
                // runs unsynchronized, it's possible that during this function this request
                // might be cancelled, and then a whole additional request might start and
                // complete inline, and cache the result. By grabbing state before we check
                // the cancellation token, we can be assured that we are only operating on
                // a state that was complete.

                ExceptionUtilities.ExecuteWithErrorReporting(() =>
                {
                    // We avoid creating a full closure just to pass the token along
                    // Also, use TaskContinuationOptions.ExecuteSynchronously so that we inline 
                    // the continuation if asynchronousComputeFunction completes synchronously
                    var task = computationToStart.AsynchronousComputeFunction(cancellationToken);

                    task.ContinueWith(
                        (t, s) => CompleteWithTask(t, ((CancellationTokenSource)s).Token),
                        computationToStart.CancellationTokenSource,
                        cancellationToken,
                        TaskContinuationOptions.ExecuteSynchronously,
                        TaskScheduler.Default);

                    if (requestToCompleteSynchronously != null && task.IsCompleted)
                    {
                        using (TakeLock(CancellationToken.None))
                        {
                            task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
                        }

                        requestToCompleteSynchronously.CompleteFromTaskSynchronously(task);
                    }
                });
            }
            catch (OperationCanceledException oce)
            {
                // As long as it's the right token, this means that our thread was the first thread
                // to start an asynchronous computation, but the requestor cancelled as we were starting up
                // the computation.
                if (oce.CancellationToken != cancellationToken)
                {
                    ExceptionUtilities.FailFast(oce);
                }
            }
        }

        private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
        {
            IEnumerable<Request> requestsToComplete;

            using (TakeLock(cancellationToken))
            {
                // If the underlying computation was cancelled, then all state was already updated in OnAsynchronousRequestCancelled
                // and there is no new work to do here. We *must* use the local one since this completion may be running far after
                // the background computation was cancelled and a new one might have already been enqueued. We must do this
                // check here under the lock to ensure proper synchronization with OnAsynchronousRequestCancelled.
                cancellationToken.ThrowIfCancellationRequested();

                // The computation is complete, so get all requests to complete and null out the list. We'll create another one
                // later if it's needed
                requestsToComplete = this.requests ?? SpecializedCollections.EmptyEnumerable<Request>();
                this.requests = null;

                // The computations are done
                this.asynchronousComputationCancellationSource = null;
                this.computationActive = false;
                task = GetCachedValueAndCacheThisValueIfNoneCached_NoLock(task);
            }

            foreach (var requestToComplete in requestsToComplete)
            {
                requestToComplete.CompleteFromTaskAsynchronously(task);
            }
        }

        private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
        {
            if (this.cachedResult != null)
            {
                return this.cachedResult;
            }
            else
            {
                if (cacheResult && task.Status == TaskStatus.RanToCompletion)
                {
                    // Hold onto the completed task. We can get rid of the computation functions for good
                    this.cachedResult = task;
                    this.asynchronousComputeFunction = null;
                    this.synchronousComputeFunction = null;
                }

                return task;
            }
        }

        private void OnAsynchronousRequestCancelled(object state)
        {
            var request = (Request)state;
            CancellationTokenSource cancellationTokenSource = null;

            using (TakeLock(CancellationToken.None))
            {
                // Now try to remove it. It's possible that requests may already be null. You could
                // imagine that cancellation was requested, but before we could aquire the lock
                // here the computation completed and the entire CompleteWithTask synchronized
                // block ran. In that case, the requests collection may already be null, or it
                // (even scarier!) may have been replaced with another collection because another
                // computation has started.
                if (this.requests != null)
                {
                    if (this.requests.Remove(request))
                    {
                        if (this.requests.Count == 0)
                        {
                            this.requests = null;

                            if (this.asynchronousComputationCancellationSource != null)
                            {
                                cancellationTokenSource = this.asynchronousComputationCancellationSource;
                                this.asynchronousComputationCancellationSource = null;
                                this.computationActive = false;
                            }
                        }
                    }
                }
            }

            request.CancelAsynchronously();

            if (cancellationTokenSource != null)
            {
                cancellationTokenSource.Cancel();
            }
        }

        // Using inheritance instead of wrapping a TaskCompletionSource to avoid a second allocation
        private class Request : TaskCompletionSource<T>
        {
            private CancellationTokenRegistration cancellationTokenRegistration;

            public void RegisterForCancellation(Action<object> callback, CancellationToken cancellationToken)
            {
                cancellationTokenRegistration = cancellationToken.Register(callback, this);
            }

            public void CompleteFromTaskAsynchronously(Task<T> task)
            {
                System.Threading.Tasks.Task.Factory.StartNew(CompleteFromTaskSynchronouslyStub, task, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CompleteFromTaskSynchronouslyStub(object task)
            {
                CompleteFromTaskSynchronously((Task<T>)task);
            }

            public void CompleteFromTaskSynchronously(Task<T> task)
            {
                if (task.Status == TaskStatus.RanToCompletion)
                {
                    if (TrySetResult(task.Result))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else if (task.Status == TaskStatus.Faulted)
                {
                    if (TrySetException(task.Exception))
                    {
                        cancellationTokenRegistration.Dispose();
                    }
                }
                else
                {
                    CancelSynchronously();
                }
            }

            public void CancelAsynchronously()
            {
                // Since there could be synchronous continuations on the TaskCancellationSource, we queue this to the threadpool
                // to avoid inline running of other operations.
                System.Threading.Tasks.Task.Factory.StartNew(CancelSynchronously, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            }

            private void CancelSynchronously()
            {
                if (TrySetCanceled())
                {
                    // Paranoia: the only reason we should ever get here is if the CancellationToken that
                    // we registered against was cancelled, but just in case, dispose the registration
                    cancellationTokenRegistration.Dispose();
                }
            }
        }
    }
    
    /// <summary>
    /// A lightweight mutual exclusion object which supports waiting with cancellation and prevents
    /// recursion (i.e. you may not call Wait if you already hold the lock)
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="NonReentrantLock"/> provides a lightweight mutual exclusion class that doesn't
    /// use Windows kernel synchronization primitives.
    /// </para>
    /// <para>
    /// The implementation is distilled from the workings of <see cref="T:System.Threading.SemaphoreSlim"/>
    /// The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting
    /// of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else
    /// then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation
    /// callback fires, then it "pulses" all the waiters to wake them up and check for cancellation.
    /// Waiters are also "pulsed" when leaving the lock.
    /// </para>
    /// <para>
    /// All public members of <see cref="NonReentrantLock"/> are thread-safe and may be used concurrently
    /// from multiple threads.
    /// </para>
    /// </remarks>
    internal sealed class NonReentrantLock
    {
        /// <summary>
        /// A synchronization object to protect access to the <see cref="F:owningThread"/> field and to be pulsed
        /// when <see cref="M:Release"/> is called and during cancellation.
        /// </summary>
        private readonly object syncLock;

        /// <summary>
        /// Indicates which thread currently holds the lock. If null, then the lock is available.
        /// </summary>
        private volatile Thread owningThread;

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="useThisInstanceForSynchronization">If false (the default), then the class
        /// allocates an internal object to be used as a sync lock.
        /// If true, then the sync lock object will be the NonReentrantLock instance itself. This
        /// saves an allocation but a client may not safely further use this instance in a call to
        /// Monitor.Enter/Exit or in a "lock" statement.
        /// </param>
        public NonReentrantLock(bool useThisInstanceForSynchronization = false)
        {
            this.syncLock = useThisInstanceForSynchronization ? this : new object();
        }

        /// <summary>
        /// Shared factory for use in lazy initialization.
        /// </summary>
        public static readonly Func<NonReentrantLock> Factory = () => new NonReentrantLock(useThisInstanceForSynchronization: true);

        /// <summary>
        /// Blocks the current thread until it can enter the <see cref="NonReentrantLock"/>, while observing a
        /// <see cref="T:System.Threading.CancellationToken"/>.
        /// </summary>
        /// <remarks>
        /// Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an
        /// intervening <see cref="Release"/>.
        /// </remarks>
        /// <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken"/> token to
        /// observe.</param>
        /// <exception cref="T:System.OperationCanceledException"><paramref name="cancellationToken"/> was
        /// canceled.</exception>
        /// <exception cref="T:System.LockRecursionException">The caller already holds the lock</exception>
        public void Wait(CancellationToken cancellationToken = default(CancellationToken))
        {
            if (this.IsOwnedByMe)
            {
                throw new LockRecursionException();
            }

            CancellationTokenRegistration cancellationTokenRegistration = default(CancellationTokenRegistration);

            if (cancellationToken.CanBeCanceled)
            {
                cancellationToken.ThrowIfCancellationRequested();

                // Fast path to try and avoid allocations in callback registration.
                lock (this.syncLock)
                {
                    if (!this.IsLocked)
                    {
                        this.TakeOwnership();
                        return;
                    }
                }

                cancellationTokenRegistration = cancellationToken.Register(cancellationTokenCanceledEventHandler, this.syncLock, useSynchronizationContext: false);
            }

            using (cancellationTokenRegistration)
            {
                // PERF: First spin wait for the lock to become available, but only up to the first planned yield.
                // This additional amount of spinwaiting was inherited from SemaphoreSlim's implementation where
                // it showed measurable perf gains in test scenarios.
                SpinWait spin = new SpinWait();
                while (this.IsLocked && !spin.NextSpinWillYield)
                {
                    spin.SpinOnce();
                }

                lock (this.syncLock)
                {
                    while (this.IsLocked)
                    {
                        // If cancelled, we throw. Trying to wait could lead to deadlock.
                        cancellationToken.ThrowIfCancellationRequested();

                        using (Logger.LogBlock(FeatureId.WaitIndicator, FunctionId.Utilities_NonReentrantLock_BlockingWait, cancellationToken))
                        {
                            // Another thread holds the lock. Wait until we get awoken either
                            // by some code calling "Release" or by cancellation.
                            Monitor.Wait(this.syncLock);
                        }
                    }

                    // We now hold the lock
                    this.TakeOwnership();
                }
            }
        }

        /// <summary>
        /// Exit the mutual exclusion.
        /// </summary>
        /// <remarks>
        /// The calling thread must currently hold the lock.
        /// </remarks>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void Release()
        {
            AssertHasLock();

            lock (this.syncLock)
            {
                this.ReleaseOwnership();

                // Release one waiter
                Monitor.Pulse(this.syncLock);
            }
        }

        /// <summary>
        /// Determine if the lock is currently held by the calling thread.
        /// </summary>
        /// <returns>True if the lock is currently held by the calling thread.</returns>
        public bool LockHeldByMe()
        {
            return this.IsOwnedByMe;
        }

        /// <summary>
        /// Throw an exception if the lock is not held by the calling thread.
        /// </summary>
        /// <exception cref="T:Roslyn.Utilities.ContractFailureException">The lock is not currently held by the calling thread.</exception>
        public void AssertHasLock()
        {
            Contract.ThrowIfFalse(LockHeldByMe());
        }

        /// <summary>
        /// Checks if the lock is currently held.
        /// </summary>
        private bool IsLocked
        {
            get
            {
                return this.owningThread != null;
            }
        }

        /// <summary>
        /// Checks if the lock is currently held by the calling thread.
        /// </summary>
        private bool IsOwnedByMe
        {
            get
            {
                return this.owningThread == Thread.CurrentThread;
            }
        }

        /// <summary>
        /// Take ownership of the lock (by the calling thread). The lock may not already
        /// be held by any other code.
        /// </summary>
        private void TakeOwnership()
        {
            Contract.Assert(!this.IsLocked);
            this.owningThread = Thread.CurrentThread;
        }

        /// <summary>
        /// Release ownership of the lock. The lock must already be held by the calling thread.
        /// </summary>
        private void ReleaseOwnership()
        {
            Contract.Assert(this.IsOwnedByMe);
            this.owningThread = null;
        }

        /// <summary>
        /// Action object passed to a cancellation token registration.
        /// </summary>
        private static readonly Action<object> cancellationTokenCanceledEventHandler = new Action<object>(CancellationTokenCanceledEventHandler);

        /// <summary>
        /// Callback executed when a cancellation token is canceled during a Wait.
        /// </summary>
        /// <param name="obj">The syncLock that protects a <see cref="NonReentrantLock "/> instance.</param>
        private static void CancellationTokenCanceledEventHandler(object obj)
        {
            lock (obj)
            {
                // Release all waiters to check their cancellation tokens.
                Monitor.PulseAll(obj);
            }
        }
    }
}

Seal/xe

I don't even know what to say, this made tnhigs so much easier!

Seal/Xc

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        temp.f = param;        
    }            
}what are you doing?

Seal/pNh

As web developers we shulod not give any notes about the browsers. The browser developers must react on user interaction and messages and to fix the possible bad software. But the case with IE 6 shows how  interesting' is to be a web developer. The problems behind us are giving an extraordinary experience. That's why we shulod be grateful.

Seal/pn

Sorry, I forgot to reply to this qutesion.  Have you had any luck getting it to work?  When are you calling stage.displayState?  Make sure it is after the application is completely loaded.  In my example I added a click handler on a button that set stage.displayState = StageDisplayState.FULL_SCREEN;

Seal/JT

using System;
class C {
    public static int i = 0;
    public void M(){
        i++;    
    }            
}

Seal/jP

using System;
class Test {
    public Test f = null;
    public void PureMethod(Test param){
        var temp = new Test();
        Console.writeln("Hello World");
        temp.f = param;        
    }            
}

Seal/jis

using System;
class XYZ {

    public static add1(int x, int y) { return x+y; }

    int f1, f2;

    public add2() { return f1+f2; }

         
}

Seal/DR

I do not remember lenirang to read, and I did not read that much as a child. I spent an inordinate amount of time in front of the boob tube.  My mom didn't know any better back then, like smoking a drinking during pregnancy and bottle feeding. God bless her! She did the best she could without the light she had at the time.