//------------------------------------------------------------------------------
// <copyright file="PageCodeDomTreeGenerator.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.Compilation {

using System;
using System.CodeDom;
using System.Reflection;
using System.Web.Configuration;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.Util;
using Debug = System.Web.Util.Debug;

internal class PageCodeDomTreeGenerator : TemplateControlCodeDomTreeGenerator {

    private PageParser _pageParser;
    PageParser Parser { get { return _pageParser; } }

    private const string fileDependenciesName = "__fileDependencies";
    private const string dependenciesLocalName = "dependencies";
    private const string outputCacheSettingsLocalName = "outputCacheSettings";
    private const string _previousPagePropertyName = "PreviousPage";
    private const string _masterPropertyName = "Master";
    private const string _styleSheetThemePropertyName = "StyleSheetTheme";
    private const string outputCacheSettingsFieldName = "__outputCacheSettings";

    internal const int  DebugScriptTimeout = 30000000;

    internal PageCodeDomTreeGenerator(PageParser pageParser) : base(pageParser) {
        _pageParser = pageParser;
    }

    /*
     * Generate the list of implemented interfaces
     */
    protected override void GenerateInterfaces() {

        base.GenerateInterfaces();

        if (Parser.FRequiresSessionState) {
            _intermediateClass.BaseTypes.Add(new CodeTypeReference(typeof(IRequiresSessionState)));
        }
        if (Parser.FReadOnlySessionState) {
            _intermediateClass.BaseTypes.Add(new CodeTypeReference(typeof(IReadOnlySessionState)));
        }

        // Skip if we're only generating the intermediate class
        if (!_designerMode && _sourceDataClass != null && (Parser.AspCompatMode || Parser.AsyncMode)) {
            _sourceDataClass.BaseTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler)));
        }
    }

    /*
     * Build first-time intialization statements
     */
    protected override void BuildInitStatements(CodeStatementCollection trueStatements, CodeStatementCollection topLevelStatements) {

        base.BuildInitStatements(trueStatements, topLevelStatements);

        // 



        CodeMemberField fileDependencies = new CodeMemberField(typeof(object), fileDependenciesName);
        fileDependencies.Attributes |= MemberAttributes.Static;
        _sourceDataClass.Members.Add(fileDependencies);

        // Note: it may look like this local variable declaration is redundant. However it is necessary
        // to make this init code re-entrant safe. This way, even if two threads enter the contructor
        // at the same time, they will not add multiple dependencies.

        // e.g. string[] dependencies;
        CodeVariableDeclarationStatement dependencies = new CodeVariableDeclarationStatement();
        dependencies.Type = new CodeTypeReference(typeof(string[]));
        dependencies.Name = dependenciesLocalName;
        // Note: it is important to add all local variables at the top level for CodeDom Subset compliance.
        topLevelStatements.Insert(0, dependencies);

        Debug.Assert(Parser.SourceDependencies != null);

        StringSet virtualDependencies = new StringSet();
        virtualDependencies.AddCollection(Parser.SourceDependencies);

        // e.g. dependencies = new string[{{virtualDependencies.Count}}];;
        CodeAssignStatement assignDependencies = new CodeAssignStatement();
        assignDependencies.Left =
            new CodeVariableReferenceExpression(dependenciesLocalName);
        assignDependencies.Right =
            new CodeArrayCreateExpression(typeof(String), virtualDependencies.Count);
        trueStatements.Add(assignDependencies);

        int i = 0;
        foreach (string virtualDependency in virtualDependencies) {
            // e.g. dependencies[i] = "~/sub/foo.aspx";
            CodeAssignStatement addFileDep = new CodeAssignStatement();
            addFileDep.Left =
                new CodeArrayIndexerExpression(
                    new CodeVariableReferenceExpression(dependenciesLocalName),
                    new CodeExpression[] {new CodePrimitiveExpression(i++)});
            string src = UrlPath.MakeVirtualPathAppRelative(virtualDependency);
            addFileDep.Right = new CodePrimitiveExpression(src);
            trueStatements.Add(addFileDep);
        }

        // e.g. __fileDependencies = this.GetWrappedFileDependencies(dependencies);
        CodeAssignStatement initFile = new CodeAssignStatement();
        initFile.Left = new CodeFieldReferenceExpression(_classTypeExpr, fileDependenciesName);
        CodeMethodInvokeExpression createWrap = new CodeMethodInvokeExpression();
        createWrap.Method.TargetObject = new CodeThisReferenceExpression();
        createWrap.Method.MethodName = "GetWrappedFileDependencies";
        createWrap.Parameters.Add(new CodeVariableReferenceExpression(dependenciesLocalName));
        initFile.Right = createWrap;

#if DBG
        AppendDebugComment(trueStatements);
#endif
        trueStatements.Add(initFile);
    }

    /*
     * Build the default constructor
     */
    protected override void BuildDefaultConstructor() {

        base.BuildDefaultConstructor();

        if (CompilParams.IncludeDebugInformation) {
            // If in debug mode, set the timeout to some huge value (ASURT 49427)
            //      Server.ScriptTimeout = 30000000;
            CodeAssignStatement setScriptTimeout = new CodeAssignStatement();
            setScriptTimeout.Left = new CodePropertyReferenceExpression(
                new CodePropertyReferenceExpression(
                    new CodeThisReferenceExpression(), "Server"),
                "ScriptTimeout");
            setScriptTimeout.Right = new CodePrimitiveExpression(DebugScriptTimeout);
            _ctor.Statements.Add(setScriptTimeout);

        }

        if (Parser.TransactionMode != 0 /*TransactionOption.Disabled*/) {
            _ctor.Statements.Add(new CodeAssignStatement(
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TransactionMode"),
                new CodePrimitiveExpression(Parser.TransactionMode)));
        }

        if (Parser.AspCompatMode) {
            _ctor.Statements.Add(new CodeAssignStatement(
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AspCompatMode"),
                new CodePrimitiveExpression(Parser.AspCompatMode)));
        }

        if (Parser.AsyncMode) {
            _ctor.Statements.Add(new CodeAssignStatement(
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AsyncMode"),
                new CodePrimitiveExpression(Parser.AsyncMode)));
        }

        if (Parser.OutputCacheParameters != null) {
            OutputCacheParameters cacheSettings = Parser.OutputCacheParameters;
            if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) ||
                cacheSettings.Duration != 0 ||
                cacheSettings.Location == OutputCacheLocation.None) {

                // Add the following code snippet as a static on the class:
                //
                // private static OutputCacheParameters __outputCacheSettings = null;
                //
                CodeMemberField outputCacheSettingsField = new CodeMemberField(typeof(OutputCacheParameters), outputCacheSettingsFieldName);
                outputCacheSettingsField.Attributes |= MemberAttributes.Static;
                outputCacheSettingsField.InitExpression = new CodePrimitiveExpression(null);
                _sourceDataClass.Members.Add(outputCacheSettingsField);

                // Then, add the following code to the default constructor:
                //
                // if (__outputCacheSettings == null)
                //     __outputCacheSettings = new OutputCacheParameters(.....)
                //

                // This is the "if (__outputCacheSettings == null)" part
                CodeConditionStatement outputCacheSettingsCondition = new CodeConditionStatement();
                outputCacheSettingsCondition.Condition = new CodeBinaryOperatorExpression(
                                                        new CodeFieldReferenceExpression(
                                                            _classTypeExpr,
                                                            outputCacheSettingsFieldName),
                                                        CodeBinaryOperatorType.IdentityEquality,
                                                        new CodePrimitiveExpression(null));

                // This is the "__outputCacheSettings = new OutputCacheParameters()" part


                // e.g. declare local variable: OutputCacheParameters outputCacheSettings;
                CodeVariableDeclarationStatement outputCacheSettingsDeclaration = new CodeVariableDeclarationStatement();
                outputCacheSettingsDeclaration.Type = new CodeTypeReference(typeof(OutputCacheParameters));
                outputCacheSettingsDeclaration.Name = outputCacheSettingsLocalName;
                outputCacheSettingsCondition.TrueStatements.Insert(0, outputCacheSettingsDeclaration);

                // e.g. outputCacheSettings = new outputCacheParameters;
                CodeObjectCreateExpression cacheSettingsObject = new CodeObjectCreateExpression();
                cacheSettingsObject.CreateType = new CodeTypeReference(typeof(OutputCacheParameters));

                CodeVariableReferenceExpression outputCacheSettings = 
                    new CodeVariableReferenceExpression(outputCacheSettingsLocalName);

                CodeAssignStatement setOutputCacheObject = 
                    new CodeAssignStatement(outputCacheSettings, cacheSettingsObject);

                // Add the statement to the "true" clause
                outputCacheSettingsCondition.TrueStatements.Add(setOutputCacheObject);

                if (cacheSettings.IsParameterSet(OutputCacheParameter.CacheProfile)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "CacheProfile"),
                                                                   new CodePrimitiveExpression(cacheSettings.CacheProfile));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.Duration)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Duration"),
                                                                   new CodePrimitiveExpression(cacheSettings.Duration));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.Enabled)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Enabled"),
                                                                   new CodePrimitiveExpression(cacheSettings.Enabled));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.Location)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Location"),
                                                                   new CodeFieldReferenceExpression(
                                                                        new CodeTypeReferenceExpression(typeof(OutputCacheLocation)), 
                                                                        cacheSettings.Location.ToString()));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.NoStore)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "NoStore"),
                                                                   new CodePrimitiveExpression(cacheSettings.NoStore));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.SqlDependency)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "SqlDependency"),
                                                                   new CodePrimitiveExpression(cacheSettings.SqlDependency));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByControl)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByControl"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByControl));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByCustom)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByCustom"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByCustom));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByContentEncoding)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByContentEncoding"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByContentEncoding));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }
                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByHeader)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByHeader"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByHeader));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByParam)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByParam"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByParam));
                    
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }

                // e.g. __outputCacheSettings = outputCacheSettings;
                CodeFieldReferenceExpression staticOutputCacheSettings = 
                    new CodeFieldReferenceExpression(_classTypeExpr, outputCacheSettingsFieldName);
                CodeAssignStatement assignOutputCacheSettings = 
                    new CodeAssignStatement(staticOutputCacheSettings, outputCacheSettings);
                // Add the statement to the "true" clause
                outputCacheSettingsCondition.TrueStatements.Add(assignOutputCacheSettings);

                _ctor.Statements.Add(outputCacheSettingsCondition);
            }
        }
    }

    /*
     * Build various properties, fields, methods
     */
    protected override void BuildMiscClassMembers() {
        base.BuildMiscClassMembers();

        // The following method should not be built in designer mode, and should only be built
        // when we're generating the full class (as opposed to the partial stub)
        if (!_designerMode && _sourceDataClass != null) {
            BuildGetTypeHashCodeMethod();

            if (Parser.AspCompatMode)
                BuildAspCompatMethods();

            if (Parser.AsyncMode)
                BuildAsyncPageMethods();

            BuildProcessRequestOverride();
        }

        if (Parser.PreviousPageType != null)
            BuildStronglyTypedProperty(_previousPagePropertyName, Parser.PreviousPageType);

        if (Parser.MasterPageType != null)
            BuildStronglyTypedProperty(_masterPropertyName, Parser.MasterPageType);


    }

    /*
     * Build the data tree for the GetTypeHashCode method
     */
    private void BuildGetTypeHashCodeMethod() {

        CodeMemberMethod method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "GetTypeHashCode";
        method.ReturnType = new CodeTypeReference(typeof(int));
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Override | MemberAttributes.Public;

        _sourceDataClass.Members.Add(method);

#if DBG
        AppendDebugComment(method.Statements);
#endif
        method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(Parser.TypeHashCode)));
    }

    internal override CodeExpression BuildPagePropertyReferenceExpression() {
        return new CodeThisReferenceExpression();
    }

    /*
     * Build the contents of the FrameworkInitialize method
     */
    protected override void BuildFrameworkInitializeMethodContents(CodeMemberMethod method) {

        // Generate code to apply stylesheet before calling base.FrameworkInitialize();
        if (Parser.StyleSheetTheme != null) {
            CodeExpression rightExpr = new CodePrimitiveExpression(Parser.StyleSheetTheme);
            CodeExpression leftExpr = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), _styleSheetThemePropertyName);
            CodeAssignStatement setStatment = new CodeAssignStatement(leftExpr, rightExpr);
            method.Statements.Add(setStatment);
        }

        base.BuildFrameworkInitializeMethodContents(method);

        CodeMethodInvokeExpression addDeps = new CodeMethodInvokeExpression();
        addDeps.Method.TargetObject = new CodeThisReferenceExpression();
        addDeps.Method.MethodName = "AddWrappedFileDependencies";
        addDeps.Parameters.Add(new CodeFieldReferenceExpression(_classTypeExpr, fileDependenciesName));
        method.Statements.Add(addDeps);

        if (Parser.OutputCacheParameters != null) {
            OutputCacheParameters cacheSettings = Parser.OutputCacheParameters;
            if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) ||
                cacheSettings.Duration != 0 ||
                cacheSettings.Location == OutputCacheLocation.None) {

                CodeMethodInvokeExpression call = new CodeMethodInvokeExpression();
                call.Method.TargetObject = new CodeThisReferenceExpression();
                call.Method.MethodName = "InitOutputCache";
                call.Parameters.Add(new CodeFieldReferenceExpression(
                                    _classTypeExpr,
                                    outputCacheSettingsFieldName));

                method.Statements.Add(call);
            }
        }

        if (Parser.TraceEnabled != TraceEnable.Default) {
            method.Statements.Add(new CodeAssignStatement(
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceEnabled"),
                new CodePrimitiveExpression(Parser.TraceEnabled == TraceEnable.Enable)));
        }

        if (Parser.TraceMode != TraceMode.Default) {
            method.Statements.Add(new CodeAssignStatement(
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceModeValue"),
                new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(TraceMode)), Parser.TraceMode.ToString())));
        }

        if (Parser.ValidateRequest) {
            // e.g. Request.ValidateInput();
            CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
            invokeExpr.Method.TargetObject = new CodePropertyReferenceExpression(
                new CodeThisReferenceExpression(), "Request");
            invokeExpr.Method.MethodName = "ValidateInput";
            method.Statements.Add(new CodeExpressionStatement(invokeExpr));
        }
        else if (MultiTargetingUtil.TargetFrameworkVersion >= VersionUtil.Framework45) {
            // Only emit the ValidateRequestMode setter if the target framework is 4.5 or higher.
            // On frameworks 4.0 and earlier that property did not exist.
            CodePropertyReferenceExpression left = new CodePropertyReferenceExpression(
                new CodeThisReferenceExpression(), "ValidateRequestMode");
            CodeFieldReferenceExpression right = new CodeFieldReferenceExpression(
                new CodeTypeReferenceExpression(typeof(ValidateRequestMode)), "Disabled");
            CodeAssignStatement statement = new CodeAssignStatement(left, right);
            method.Statements.Add(statement);
        }
    }

    /*
     * Build the data tree for the AspCompat implementation for IHttpAsyncHandler:
     */
    private void BuildAspCompatMethods() {
        CodeMemberMethod method;
        CodeMethodInvokeExpression call;

        //  public IAsyncResult BeginProcessRequest(HttpContext context, Async'back cb, Object extraData) {
        //      IAsyncResult ar;
        //      ar = this.AspCompatBeginProcessRequest(context, cb, extraData);
        //      return ar;
        //  }

        method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "BeginProcessRequest";
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Public;
        method.ImplementationTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler)));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext),   "context"));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), "cb"));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Object),        "data"));
        method.ReturnType = new CodeTypeReference(typeof(IAsyncResult));

        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
        invokeExpr.Method.TargetObject = new CodeThisReferenceExpression();
        invokeExpr.Method.MethodName = "AspCompatBeginProcessRequest";
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context"));
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("cb"));
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("data"));

        method.Statements.Add(new CodeMethodReturnStatement(invokeExpr));

        _sourceDataClass.Members.Add(method);

        //  public void EndProcessRequest(IAsyncResult ar) {
        //      this.AspCompatEndProcessRequest(ar);
        //  }

        method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "EndProcessRequest";
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Public;
        method.ImplementationTypes.Add(typeof(IHttpAsyncHandler));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), "ar"));

        call = new CodeMethodInvokeExpression();
        call.Method.TargetObject = new CodeThisReferenceExpression();
        call.Method.MethodName = "AspCompatEndProcessRequest";
        call.Parameters.Add(new CodeArgumentReferenceExpression("ar"));
        method.Statements.Add(call);

        _sourceDataClass.Members.Add(method);
    }

    /*
     * Build the data tree for the Async page implementation for IHttpAsyncHandler:
     */
    private void BuildAsyncPageMethods() {
        CodeMemberMethod method;
        CodeMethodInvokeExpression call;

        //  public IAsyncResult BeginProcessRequest(HttpContext context, Async'back cb, Object extraData) {
        //      IAsyncResult ar;
        //      ar = this.AsyncPageBeginProcessRequest(context, cb, extraData);
        //      return ar;
        //  }

        method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "BeginProcessRequest";
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Public;
        method.ImplementationTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler)));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext),   "context"));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), "cb"));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Object),        "data"));
        method.ReturnType = new CodeTypeReference(typeof(IAsyncResult));

        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
        invokeExpr.Method.TargetObject = new CodeThisReferenceExpression();
        invokeExpr.Method.MethodName = "AsyncPageBeginProcessRequest";
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context"));
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("cb"));
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("data"));

        method.Statements.Add(new CodeMethodReturnStatement(invokeExpr));

        _sourceDataClass.Members.Add(method);

        //  public void EndProcessRequest(IAsyncResult ar) {
        //      this.AsyncPageEndProcessRequest(ar);
        //  }

        method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "EndProcessRequest";
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Public;
        method.ImplementationTypes.Add(typeof(IHttpAsyncHandler));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), "ar"));

        call = new CodeMethodInvokeExpression();
        call.Method.TargetObject = new CodeThisReferenceExpression();
        call.Method.MethodName = "AsyncPageEndProcessRequest";
        call.Parameters.Add(new CodeArgumentReferenceExpression("ar"));
        method.Statements.Add(call);

        _sourceDataClass.Members.Add(method);
    }

    /*
     * Build a ProcessRequest override which just calls the base.  This is used to make sure
     * there is user code on the stack when requests are executed (VSWhidbey 499386)
     */
    private void BuildProcessRequestOverride() {

        //  public override void ProcessRequest(HttpContext context) {
        //      base.ProcessRequest(context);
        //  }

        CodeMemberMethod method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "ProcessRequest";
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;

        // If the base type is non-default (i.e. not Page) we have to be careful overriding
        // ProcessRequest, because if the base has its own IHttpHandler.ProcessRequest implementation
        // and it's not overridable, we would fail to compile.  So when we detect this situation,
        // we instead generate it as a new IHttpHandler.ProcessRequest implementation instead of an
        // override.  In theory, we could *always* do this, but it's safer to limit it to this
        // constrained scenario (VSWhidbey 517240)
        MethodInfo methodInfo = null;
        if (Parser.BaseType != typeof(Page)) {
            methodInfo = Parser.BaseType.GetMethod("ProcessRequest",
                BindingFlags.Public | BindingFlags.Instance,
                null, new Type[] { typeof(HttpContext) }, null);
            Debug.Assert(methodInfo != null);
        }

        _sourceDataClass.BaseTypes.Add(new CodeTypeReference(typeof(IHttpHandler)));

        if (methodInfo != null && methodInfo.DeclaringType != typeof(Page)) {
            method.Attributes |= MemberAttributes.New | MemberAttributes.Public;
        }
        else {
            method.Attributes |= MemberAttributes.Override | MemberAttributes.Public;
        }

        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext), "context"));

        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
        invokeExpr.Method.TargetObject = new CodeBaseReferenceExpression();
        invokeExpr.Method.MethodName = "ProcessRequest";
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context"));

        method.Statements.Add(invokeExpr);

        _sourceDataClass.Members.Add(method);
    }

}

}