//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Activities.Debugger
{

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Diagnostics.CodeAnalysis;
    using System.Diagnostics.SymbolStore;
    using System.Globalization;
    using System.Reflection;
    using System.Reflection.Emit;
    using System.Runtime;
    using System.Security;
    using System.Security.Permissions;
    using System.Activities.Debugger.Symbol;

    // Manager for supporting debugging a state machine.
    // The general usage is to call:
    //  - DefineState() for each state
    //  - Bake() once you've defined all the states you need to enter.
    //  - EnterState() / LeaveState() for each state.
    // You can Define new states and bake them, such as if the script loads a new file.
    // Baking is expensive, so it's best to define as many states in each batch.
    [DebuggerNonUserCode]
    // This class need not serialized.
    [Fx.Tag.XamlVisible(false)]
    public sealed class StateManager : IDisposable
    {
        static readonly Guid WorkflowLanguageGuid = new Guid("1F1149BB-9732-4EB8-9ED4-FA738768919C");

        static readonly LocalsItemDescription[] debugInfoDescriptions = new LocalsItemDescription[] {
                new LocalsItemDescription("debugInfo", typeof(DebugInfo))
            };

        static Type threadWorkerControllerType = typeof(ThreadWorkerController);
        static MethodInfo islandWorkerMethodInfo = threadWorkerControllerType.GetMethod("IslandWorker", BindingFlags.Static | BindingFlags.Public);
        internal const string MethodWithPrimingPrefix = "_";

        List<LogicalThread> threads;

        DynamicModuleManager dynamicModuleManager;

        // Don't expose this, because that would expose the setters. Changing the properties
        // after baking types has undefined semantics and would be confusing to the user.
        Properties properties;

        bool debugStartedAtRoot;

        // Simple default constructor.
        internal StateManager()
            : this(new Properties(), true, null)
        {
        }


        // Constructor.
        // Properties must be set at creation time.
        internal StateManager(Properties properties, bool debugStartedAtRoot, DynamicModuleManager dynamicModuleManager)
        {
            this.properties = properties;
            this.debugStartedAtRoot = debugStartedAtRoot;
            this.threads = new List<LogicalThread>();
            if (dynamicModuleManager == null)
            {
                dynamicModuleManager = new DynamicModuleManager(this.properties.ModuleNamePrefix);
            }
            this.dynamicModuleManager = dynamicModuleManager;
        }

        internal Properties ManagerProperties
        {
            get { return this.properties; }
        }

        internal bool IsPriming
        {
            get;
            set;
        }

        // Whether debugging is started at the root workflow (contrast to attaching in the middle 
        // of a running workflow.
        internal bool DebugStartedAtRoot
        {
            get
            {
                return this.debugStartedAtRoot;
            }
        }

        // Declare a new state associated with the given source location.
        // States should have disjoint source locations. 
        // location is Source location associated with this state.
        // This returns a state object, which can be passed to EnterState.
        internal State DefineState(SourceLocation location)
        {
            return DefineState(location, string.Empty, null, 0);
        }

        internal State DefineState(SourceLocation location, string name)
        {
            return DefineState(location, name, null, 0);
        }

        internal State DefineState(SourceLocation location, string name, LocalsItemDescription[] earlyLocals, int numberOfEarlyLocals)
        {
            return this.dynamicModuleManager.DefineState(location, name, earlyLocals, numberOfEarlyLocals);
        }

        internal State DefineStateWithDebugInfo(SourceLocation location, string name)
        {
            return DefineState(location, name, debugInfoDescriptions, debugInfoDescriptions.Length);
        }


        // Bake all states using the default type namespace.
        // States must be baked before calling EnterState().
        internal void Bake()
        {
            Bake(this.properties.TypeNamePrefix, null);
        }


        // Bake all newly defined states. States must be baked before calling EnterState().
        // typeName is the type name that the islands are contained in. This
        // may show up on the callstack. If this is not unique, it will be appended with a unique
        // identifier.
        internal void Bake(string typeName, Dictionary<string, byte[]> checksumCache)
        {
            this.dynamicModuleManager.Bake(typeName, this.properties.TypeNamePrefix, checksumCache);
        }

        internal int CreateLogicalThread(string threadName)
        {
            int threadId = -1;

            // Reuse thread if exists
            // Start from 1 since main thread never disposed earlier.
            for (int i = 1; i < this.threads.Count; ++i)
            {
                if (this.threads[i] == null)
                {
                    this.threads[i] = new LogicalThread(i, threadName, this);
                    threadId = i;
                    break;
                }
            }

            // If can't reuse old thread.
            if (threadId < 0)
            {
                threadId = this.threads.Count;
                this.threads.Add(new LogicalThread(threadId, threadName, this));
            }

            return threadId;
        }

        // Push the state onto the virtual callstack, with no locals.
        // State is the state to push onto stack.
        //internal void EnterState(int threadIndex, State state)
        //{
        //    this.EnterState(threadIndex, state, null); 
        //}


        // Enter a state and push it onto the 'virtual callstack'.
        // If the user set a a breakpoint at the source location associated with
        // this state, this call will hit that breakpoint.
        // Call LeaveState when the interpretter is finished with this state.
        //
        // State is state to enter.
        // "locals" is local variables (both early-bound and late-bound) associated with this state.
        // Early-bound locals match by name with the set passed into DefineState.
        // Late-bound will be displayed read-only to the user in the watch window.</param>
        // 
        // EnterState can be called reentrantly. If code calls Enter(A); Enter(B); Enter(C);
        // Then on the call to Enter(C), the virtual callstack will be A-->B-->C.
        // Each call to Enter() will rebuild the virtual callstack.
        //
        internal void EnterState(int threadIndex, State state, IDictionary<string, object> locals)
        {
            this.EnterState(threadIndex, new VirtualStackFrame(state, locals));
        }

        // Enter a state and push it onto the 'virtual callstack'.
        // Stackframe describing state to enter, along with the
        // locals in that state.
        internal void EnterState(int threadIndex, VirtualStackFrame stackFrame)
        {
            Fx.Assert(threadIndex < this.threads.Count, "Index out of range for thread");
            Fx.Assert(this.threads[threadIndex] != null, "LogicalThread is null");
            this.threads[threadIndex].EnterState(stackFrame);
        }

        // Pop the state most recently pushed by EnterState.
        internal void LeaveState(int threadIndex, State state)
        {
            Fx.Assert(threadIndex < this.threads.Count, "Index out of range for thread");
            Fx.Assert(this.threads[threadIndex] != null, "LogicalThread is null");
            this.threads[threadIndex].LeaveState(state);
        }

        // Common helper to invoke an Stack frame. 
        // This handles marshaling the args. 
        // islandArguments - arbitrary argument passed ot the islands. 
        // [DebuggerHidden]
        internal void InvokeWorker(object islandArguments, VirtualStackFrame stackFrame)
        {
            State state = stackFrame.State;
            if (!state.DebuggingEnabled)
            {
                // We need to short circuit and call IslandWorker because that is what the generated code
                // would have done, if we had generated it. This causes the thread to finish up.
                ThreadWorkerController.IslandWorker((ThreadWorkerController)islandArguments);
                return;
            }

            MethodInfo methodInfo = this.dynamicModuleManager.GetIsland(state, this.IsPriming);
            IDictionary<string, object> allLocals = stackFrame.Locals;

            // Package up the raw arguments array.
            const int numberOfBaseArguments = 2;
            int numberOfEarlyLocals = state.NumberOfEarlyLocals;
            object[] arguments = new object[numberOfBaseArguments + numberOfEarlyLocals]; // +1 for IslandArguments and +1 for IsPriming
            arguments[0] = this.IsPriming;
            arguments[1] = islandArguments;
            if (numberOfEarlyLocals > 0)
            {
                int i = numberOfBaseArguments;
                foreach (LocalsItemDescription localsItemDescription in state.EarlyLocals)
                {
                    string name = localsItemDescription.Name;
                    object value;
                    if (allLocals.TryGetValue(name, out value))
                    {
                        // We could assert that val.GetType() is assignable to localsItemDescription.Type.
                        // MethodInfo invoke will check this anyways; but we could check
                        // it and give a better error.
                    }
                    else
                    {
                        // Local not supplied in the array! Use a default.
                        value = Activator.CreateInstance(localsItemDescription.Type);
                    }
                    arguments[i] = value;
                    i++;
                }
            }
            methodInfo.Invoke(null, arguments);
        }



        // Release any unmanaged resources.
        // This may not necessarily unload islands or dynamic modules that were created until the calling appdomain has exited.
        public void Dispose()
        {
            ExitThreads();
        }

        internal void ExitThreads()
        {
            foreach (LogicalThread logicalThread in this.threads)
            {
                if (logicalThread != null)
                {
                    logicalThread.Exit();
                }
            }
            this.threads.Clear();
        }


        // Release any unmanaged resources.
        // This may not necessarily unload islands or dynamic modules that were created until the calling appdomain has exited.
        public void Exit(int threadIndex)
        {
            Fx.Assert(threadIndex >= 0, "Invalid thread index");
            Fx.Assert(this.threads[threadIndex] != null, "Cannot dispose null LogicalThread");
            LogicalThread thread = this.threads[threadIndex];
            thread.Exit();

            // Null the entry on the List for future reuse.
            this.threads[threadIndex] = null;
        }

        // Property bag for Manager. These provide customization hooks.
        // All properties have valid default values.
        [DebuggerNonUserCode]
        internal class Properties
        {
            public Properties() :
                this("Locals", "Script", "States", "WorkflowDebuggerThread", true)
            {
            }

            public Properties(string defaultLocalsName, string moduleNamePrefix, string typeNamePrefix, string auxiliaryThreadName, bool breakOnStartup)
            {
                this.DefaultLocalsName = defaultLocalsName;
                this.ModuleNamePrefix = moduleNamePrefix;
                this.TypeNamePrefix = typeNamePrefix;
                this.AuxiliaryThreadName = auxiliaryThreadName;
                this.BreakOnStartup = breakOnStartup;
            }

            public string DefaultLocalsName
            {
                get;
                set;
            }

            // The name of the dynamic module (not including extension) that the states are emitted to.
            // This may show up on the callstack.
            // This is a prefix because there may be multiple modules for the islands.
            public string ModuleNamePrefix
            {
                get;
                set;
            }

            // Typename that states are created in.
            // This is a prefix because there may be multiple Types for the islands
            // (such as if islands are created lazily).
            public string TypeNamePrefix
            {
                get;
                set;
            }

            // If UseAuxiliaryThread is true, sets the friendly name of that thread as visible
            // in the debugger's window.
            public string AuxiliaryThreadName
            {
                get;
                set;
            }

            // If true, the VM issues a Debugger.Break() before entering the first state.
            // This can be useful for an F11 experience on startup to stop at the first state.
            // If this is false, then the interpreter will run until it hits a breakpoint or some
            // other stopping event.
            public bool BreakOnStartup
            {
                get;
                set;
            }
        }

        [DebuggerNonUserCode]
        class LogicalThread
        {
            int threadId;
            Stack<VirtualStackFrame> callStack;
            ThreadWorkerController controller;

            public LogicalThread(int threadId, string threadName, StateManager stateManager)
            {
                this.threadId = threadId;
                this.callStack = new Stack<VirtualStackFrame>();
                this.controller = new ThreadWorkerController();
                this.controller.Initialize(threadName + "." + threadId.ToString(CultureInfo.InvariantCulture), stateManager);
            }

            // Unwind call stack cleanly.
            void UnwindCallStack()
            {
                while (this.callStack.Count > 0)
                { // LeaveState will do the popping.
                    this.LeaveState(this.callStack.Peek().State);
                }
            }

            public void Exit()
            {
                this.UnwindCallStack();
                this.controller.Exit();
            }

            // Enter a state and push it onto the 'virtual callstack'.
            // Stackframe describing state to enter, along with the
            // locals in that state.
            public void EnterState(VirtualStackFrame stackFrame)
            {
                if (stackFrame != null && stackFrame.State != null)
                {
                    this.callStack.Push(stackFrame);
                    this.controller.EnterState(stackFrame);
                }
                else
                { // signify "Uninstrumented call"
                    this.callStack.Push(null);
                }
            }

            // Pop the state most recently pushed by EnterState.
            [SuppressMessage(FxCop.Category.Usage, FxCop.Rule.ReviewUnusedParameters, Justification = "Revisit for bug 36860")]
            public void LeaveState(State state)
            {
                if (this.callStack.Count > 0)
                {
                    VirtualStackFrame stackFrame = this.callStack.Pop();
                    Fx.Assert(
                        (state == null && stackFrame == null) ||
                        (stackFrame != null && stackFrame.State == state),
                        "Unmatched LeaveState: " +
                        ((state == null) ? "null" : state.Name) +
                        " with top stack frame: " +
                        ((stackFrame == null || stackFrame.State == null) ? "null" : stackFrame.State.Name));

                    if (stackFrame != null)    // Matches with an uninstrumented Activity.
                    {
                        this.controller.LeaveState();
                    }
                }
                else
                {
                    Fx.Assert("Unmatched LeaveState: " + ((state != null) ? state.Name : "null"));
                }
            }
        }

        internal class DynamicModuleManager
        {
            // List of all state that have been created with DefineState.
            List<State> states;
            Dictionary<SourceLocation, State> stateMap = new Dictionary<SourceLocation, State>();

            // Index into states array of the last set of states baked.
            // So Bake() will build islands for each state 
            // { states[x], where indexLastBaked <= x < states.Length; }
            int indexLastBaked;

            // Mapping from State --> MethodInfo for that state.
            // This gets populated as states get baked
            [Fx.Tag.SecurityNote(Critical = "Used in generating the dynamic assembly.")]
            [SecurityCritical]
            Dictionary<State, MethodInfo> islands;
            [Fx.Tag.SecurityNote(Critical = "Used in generating the dynamic assembly.")]
            [SecurityCritical]
            Dictionary<State, MethodInfo> islandsWithPriming;
            [Fx.Tag.SecurityNote(Critical = "Used in generating the dynamic assembly.")]
            [SecurityCritical]
            ModuleBuilder dynamicModule;
            [Fx.Tag.SecurityNote(Critical = "Used in generating the dynamic assembly.")]
            [SecurityCritical]
            Dictionary<string, ISymbolDocumentWriter> sourceDocuments;

            [Fx.Tag.SecurityNote(Critical = "Accesses Critical members and calling Critical method InitDynamicModule.",
                Safe = "We are only creating empty dictionaries, not populating them. And we are validating the provided moduleNamePrefix in partial trust.")]
            [SecuritySafeCritical]
            public DynamicModuleManager(string moduleNamePrefix)
            {
                this.states = new List<State>();
                this.islands = new Dictionary<State, MethodInfo>();
                this.islandsWithPriming = new Dictionary<State, MethodInfo>();
                this.sourceDocuments = new Dictionary<string, ISymbolDocumentWriter>();

                if (!PartialTrustHelpers.AppDomainFullyTrusted)
                {
                    moduleNamePrefix = State.ValidateIdentifierString(moduleNamePrefix);
                }

                InitDynamicModule(moduleNamePrefix);
            }

            public State DefineState(SourceLocation location, string name, LocalsItemDescription[] earlyLocals, int numberOfEarlyLocals)
            {
                State state;
                lock (this)
                {
                    if (!this.stateMap.TryGetValue(location, out state))
                    {
                        lock (this)
                        {
                            state = new State(location, name, earlyLocals, numberOfEarlyLocals);
                            this.stateMap.Add(location, state);
                            this.states.Add(state);
                        }
                    }
                }
                return state;
            }

            // Bake all newly defined states. States must be baked before calling EnterState().
            // typeName is the type name that the islands are contained in. This
            // may show up on the callstack. If this is not unique, it will be appended with a unique
            // identifier.
            [Fx.Tag.SecurityNote(Critical = "Accesses Critical members and invoking Critical methods.",
                Safe = "We validating the input strings - typeName and typeNamePrefix - and the checksum values in the checksumCache.")]
            [SecuritySafeCritical]
            public void Bake(string typeName, string typeNamePrefix, Dictionary<string, byte[]> checksumCache)
            {
                // In partial trust, validate the typeName and typeNamePrefix.
                if (!PartialTrustHelpers.AppDomainFullyTrusted)
                {
                    typeName = State.ValidateIdentifierString(typeName);
                    typeNamePrefix = State.ValidateIdentifierString(typeNamePrefix);

                    if (checksumCache != null)
                    {
                        bool nullifyChecksumCache = false;
                        foreach (KeyValuePair<string, byte[]> kvpair in checksumCache)
                        {
                            // We use an MD5 hash for the checksum, so the byte array should be 16 elements long.
                            if (!SymbolHelper.ValidateChecksum(kvpair.Value))
                            {
                                nullifyChecksumCache = true;
                                Trace.WriteLine(SR.DebugSymbolChecksumValueInvalid);
                                break;
                            }
                        }

                        // If we found an invalid checksum, just don't use the cache.
                        if (nullifyChecksumCache)
                        {
                            checksumCache = null;
                        }
                    }
                }

                lock (this)
                {
                    if (this.indexLastBaked < this.states.Count)    // there are newly created states.
                    {
                        // Ensure typename is unique. Append a number if needed.
                        int suffix = 1;
                        while (this.dynamicModule.GetType(typeName) != null)
                        {
                            typeName = typeNamePrefix + "_" + suffix.ToString(CultureInfo.InvariantCulture);
                            ++suffix;
                        }

                        TypeBuilder typeBuilder = this.dynamicModule.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Class);

                        for (int i = indexLastBaked; i < this.states.Count; i++)
                        {
                            // Only create the island if debugging is enabled for the state.
                            if (this.states[i].DebuggingEnabled)
                            {
                                MethodBuilder methodBuilder = this.CreateIsland(typeBuilder, this.states[i], false, checksumCache);
                                Fx.Assert(methodBuilder != null, "CreateIsland call should have succeeded");

                                // Always generate method with priming, for the following scenario:
                                //  1. Start debugging a workflow inside VS, workflow debug session 1 starts (debugStartedAtRoot = true, instrumentation is done)
                                //  2. Workflow persisted, workflow debug session 1 ends
                                //  3. Workflow continued, workflow debug session 2 starts (debugStartedAtRoot = false, instrumentation is skipped because the static dynamicModuleManager is being reused and the instrumentation is done)
                                //  4. PrimeCallStack is called to rebuild the call stack
                                //  5. NullReferenceException will be thrown if MethodInfo with prime is not available
                                MethodBuilder methodBuilderWithPriming = this.CreateIsland(typeBuilder, this.states[i], true, checksumCache);
                                Fx.Assert(methodBuilderWithPriming != null, "CreateIsland call should have succeeded");

                                // Save information needed to call Type.GetMethod() later.
                                this.states[i].CacheMethodInfo(typeBuilder, methodBuilder.Name);
                            }
                        }

                        // Actual baking.
                        typeBuilder.CreateType();

                        // Calling Type.GetMethod() is slow (10,000 calls can take ~1 minute).
                        // So defer that to later.

                        this.indexLastBaked = this.states.Count;
                    }
                }
            }

            [Fx.Tag.SecurityNote(Critical = "Used in generating the dynamic module.")]
            [SecurityCritical]
            internal MethodBuilder CreateMethodBuilder(TypeBuilder typeBuilder, Type typeIslandArguments, State state, bool withPriming)
            {
                // create the method            
                string methodName = (state.Name != null ? state.Name : ("Line_" + state.Location.StartLine));

                if (withPriming)
                {
                    methodName = MethodWithPrimingPrefix + methodName;
                }

                // Parameters to the islands:
                // 1. Args
                // 2. IDict of late-bound locals.
                // 3 ... N.  list of early bound locals.
                const int numberOfBaseArguments = 2;
                IEnumerable<LocalsItemDescription> earlyLocals = state.EarlyLocals;
                int numberOfEarlyLocals = state.NumberOfEarlyLocals;

                Type[] parameterTypes = new Type[numberOfBaseArguments + numberOfEarlyLocals];
                parameterTypes[0] = typeof(bool);
                parameterTypes[1] = typeIslandArguments;

                if (numberOfEarlyLocals > 0)
                {
                    int i = numberOfBaseArguments;
                    foreach (LocalsItemDescription localsItemDescription in earlyLocals)
                    {
                        parameterTypes[i] = localsItemDescription.Type;
                        i++;
                    }
                }

                Type returnType = typeof(void);
                MethodBuilder methodbuilder = typeBuilder.DefineMethod(
                    methodName,
                    MethodAttributes.Static | MethodAttributes.Public,
                    returnType, parameterTypes);

                // Need to define parameter here, otherwise EE cannot get the correct IDebugContainerField
                // for debugInfo.
                methodbuilder.DefineParameter(1, ParameterAttributes.None, "isPriming");
                methodbuilder.DefineParameter(2, ParameterAttributes.None, "typeIslandArguments");

                // Define the parameter names
                // Note that we can hide implementation-specific arguments from VS by not defining parameter 
                // info for them.  Eg., the StepInTarget argument doesn't appear to show up in VS at all.
                if (numberOfEarlyLocals > 0)
                {
                    int i = numberOfBaseArguments + 1;
                    foreach (LocalsItemDescription localsItemDescription in earlyLocals)
                    {
                        methodbuilder.DefineParameter(i, ParameterAttributes.None, localsItemDescription.Name);
                        i++;
                    }
                }

                return methodbuilder;
            }


            [Fx.Tag.InheritThrows(From = "GetILGenerator", FromDeclaringType = typeof(MethodBuilder))]
            [Fx.Tag.SecurityNote(Critical = "Used in generating the dynamic module.")]
            [SecurityCritical]
            MethodBuilder CreateIsland(TypeBuilder typeBuilder, State state, bool withPrimingTest, Dictionary<string, byte[]>checksumCache)
            {
                MethodBuilder methodbuilder = this.CreateMethodBuilder(typeBuilder, threadWorkerControllerType, state, withPrimingTest);
                ILGenerator ilGenerator = methodbuilder.GetILGenerator();
                const int lineHidden = 0xFeeFee; // #line hidden directive

                // Island:
                // void MethodName(Manager m)
                // {
                //    .line
                //     nop
                //     call Worker(m)
                //     ret;
                // }
                SourceLocation stateLocation = state.Location;
                ISymbolDocumentWriter document = this.GetSourceDocument(stateLocation.FileName, stateLocation.Checksum, checksumCache);
                Label islandWorkerLabel = ilGenerator.DefineLabel();

                // Hide all the opcodes before the real source line.
                // This is needed for Island which is called during priming (Attach to Process):
                // It should skip the line directive during priming, thus it won't break at user's
                // breakpoints at the beginning during priming the callstack.
                if (withPrimingTest)
                {
                    ilGenerator.MarkSequencePoint(document, lineHidden, 1, lineHidden, 100);
                    ilGenerator.Emit(OpCodes.Ldarg_0);
                    ilGenerator.Emit(OpCodes.Brtrue, islandWorkerLabel);
                }

                // Emit sequence point before the IL instructions to map it to a source location.
                ilGenerator.MarkSequencePoint(document, stateLocation.StartLine, stateLocation.StartColumn, stateLocation.EndLine, stateLocation.EndColumn);
                ilGenerator.Emit(OpCodes.Nop);

                ilGenerator.MarkLabel(islandWorkerLabel);
                ilGenerator.Emit(OpCodes.Ldarg_1);
                ilGenerator.EmitCall(OpCodes.Call, islandWorkerMethodInfo, null);
                ilGenerator.Emit(OpCodes.Ret);

                return methodbuilder;
            }

            [SuppressMessage(FxCop.Category.Security, FxCop.Rule.SecureAsserts, Justification = "The validations of the user input are done elsewhere.")]
            [Fx.Tag.SecurityNote(Critical = "Because we Assert UnmanagedCode in order to be able to emit symbols.")]
            [SecurityCritical]
            void InitDynamicModule(string asmName)
            {
                // See http://blogs.msdn.com/Microsoft/archive/2005/02/03/366429.aspx for a simple example
                // of debuggable reflection-emit.
                Fx.Assert(dynamicModule == null, "can only be initialized once");

                // create a dynamic assembly and module 
                AssemblyName assemblyName = new AssemblyName();
                assemblyName.Name = asmName;

                AssemblyBuilder assemblyBuilder;

                // The temporary assembly needs to be Transparent.
                ConstructorInfo transparentCtor =
                    typeof(SecurityTransparentAttribute).GetConstructor(
                        Type.EmptyTypes);
                CustomAttributeBuilder transparent = new CustomAttributeBuilder(
                    transparentCtor,
                    new Object[] { });

                assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run, null, true, new CustomAttributeBuilder[] { transparent });

                // Mark generated code as debuggable. 
                // See http://blogs.msdn.com/rmbyers/archive/2005/06/26/432922.aspx for explanation.        
                Type debuggableAttributeType = typeof(DebuggableAttribute);
                ConstructorInfo constructorInfo = debuggableAttributeType.GetConstructor(new Type[] { typeof(DebuggableAttribute.DebuggingModes) });
                CustomAttributeBuilder builder = new CustomAttributeBuilder(constructorInfo, new object[] {
                    DebuggableAttribute.DebuggingModes.DisableOptimizations |
                    DebuggableAttribute.DebuggingModes.Default
                });
                assemblyBuilder.SetCustomAttribute(builder);

                // We need UnmanagedCode permissions because we are asking for Symbols to be emitted.
                // We are protecting the dynamicModule so that only Critical code modifies it.
                PermissionSet unmanagedCodePermissionSet = new PermissionSet(PermissionState.None);
                unmanagedCodePermissionSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.UnmanagedCode));
                unmanagedCodePermissionSet.Assert();
                try
                {

                    dynamicModule = assemblyBuilder.DefineDynamicModule(asmName, true); // <-- pass 'true' to track debug info.

                }
                finally
                {
                    CodeAccessPermission.RevertAssert();
                }

            }

            [Fx.Tag.SecurityNote(Critical = "Used in generating the dynamic module.",
                Safe = "State validates its SecurityCritical members itself")]
            [SecuritySafeCritical]
            public MethodInfo GetIsland(State state, bool isPriming)
            {
                MethodInfo island = null;

                if (isPriming)
                {
                    lock (islandsWithPriming)
                    {
                        if (!islandsWithPriming.TryGetValue(state, out island))
                        {
                            island = state.GetMethodInfo(true);
                            islandsWithPriming[state] = island;
                        }
                    }
                }
                else
                {
                    lock (islands)
                    {
                        if (!islands.TryGetValue(state, out island))
                        {
                            island = state.GetMethodInfo(false);
                            islands[state] = island;
                        }
                    }
                }
                return island;
            }

            // This method is only called from CreateIsland, which is only called from Bake.
            // Bake does a "lock(this)" before calling CreateIsland, so access to the sourceDocuments
            // dictionary is protected by that lock. If this changes, locking will need to be added
            // to this method to protect the sourceDocuments dictionary.
            [Fx.Tag.SecurityNote(Critical = "Used in generating the dynamic module.")]
            [SecurityCritical]
            private ISymbolDocumentWriter GetSourceDocument(string fileName, byte[] checksum, Dictionary<string, byte[]> checksumCache)
            {
                ISymbolDocumentWriter documentWriter;
                string sourceDocKey = fileName + SymbolHelper.GetHexStringFromChecksum(checksum);

                if (!this.sourceDocuments.TryGetValue(sourceDocKey, out documentWriter))
                {
                    documentWriter =
                        dynamicModule.DefineDocument(
                        fileName,
                        StateManager.WorkflowLanguageGuid,
                        SymLanguageVendor.Microsoft,
                        SymDocumentType.Text);
                    this.sourceDocuments.Add(sourceDocKey, documentWriter);

                    byte[] checksumBytes;

                    if (checksumCache == null || !checksumCache.TryGetValue(fileName.ToUpperInvariant(), out checksumBytes))
                    {
                        checksumBytes = SymbolHelper.CalculateChecksum(fileName);
                    }

                    if (checksumBytes != null)
                    {
                        documentWriter.SetCheckSum(SymbolHelper.ChecksumProviderId, checksumBytes);
                    }
                }
                return documentWriter;
            }

        }
    }
}