public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
            string endBlock = context.BuildCodeString(cw =>
            {
                if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
                {
                    if (!context.Host.DesignTimeMode)
                    {
                        cw.WriteEndMethodInvoke();
                    }
                    cw.WriteEndStatement();
                }
                else
                {
                    cw.WriteLineContinuation();
                }
            });

            context.MarkEndOfGeneratedCode();
            context.BufferStatementFragment(endBlock);
            context.FlushBufferedStatement();

            if (context.Host.EnableInstrumentation && context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
            {
                Span contentSpan = target.Children
                    .OfType<Span>()
                    .Where(s => s.Kind == SpanKind.Code || s.Kind == SpanKind.Markup)
                    .FirstOrDefault();

                if (contentSpan != null)
                {
                    context.AddContextCall(contentSpan, context.Host.GeneratedClassContext.EndContextMethodName, false);
                }
            }
        }

        internal static CodeGeneratorContext Create(RazorEngineHost host, Func<CodeWriter> writerFactory, string className, string rootNamespace, string sourceFile, bool shouldGenerateLinePragmas)
        {
            CodeGeneratorContext context = new CodeGeneratorContext()
            {
                Host = host,
                CodeWriterFactory = writerFactory,
                SourceFile = shouldGenerateLinePragmas ? sourceFile : null,
                CompileUnit = new CodeCompileUnit(),
                Namespace = new CodeNamespace(rootNamespace),
                GeneratedClass = new CodeTypeDeclaration(className)
                {
                    IsClass = true
                },
                TargetMethod = new CodeMemberMethod()
                {
                    Name = host.GeneratedClassContext.ExecuteMethodName,
                    Attributes = MemberAttributes.Override | MemberAttributes.Public
                },
                CodeMappings = new Dictionary<int, GeneratedCodeMapping>()
            };
            context.CompileUnit.Namespaces.Add(context.Namespace);
            context.Namespace.Types.Add(context.GeneratedClass);
            context.GeneratedClass.Members.Add(context.TargetMethod);

            context.Namespace.Imports.AddRange(host.NamespaceImports
                                                   .Select(s => new CodeNamespaceImport(s))
                                                   .ToArray());

            return context;
        }

		public override void GenerateStartBlockCode (Block target, CodeGeneratorContext context)
		{
			if (context.Host.DesignTimeMode)
				return;

			context.FlushBufferedStatement();

			var sb = new StringBuilder ();
			if (!string.IsNullOrEmpty (context.TargetWriterName)) {
				sb.AppendFormat (
					"{0} ({1}, ",
					context.Host.GeneratedClassContext.WriteAttributeToMethodName,
					context.TargetWriterName
				);
			} else {
				sb.AppendFormat (
					"{0} (",
					context.Host.GeneratedClassContext.WriteAttributeMethodName
				);
			}
			sb.WriteCStyleStringLiteral (Name);
			sb.Append (", ");
			sb.WriteCStyleStringLiteral (Prefix);
			sb.Append (", ");
			sb.WriteCStyleStringLiteral (Suffix);

			context.AddStatement (sb.ToString ());
		}

		public override void GenerateStartBlockCode (Block target, CodeGeneratorContext context)
		{
			if (context.Host.DesignTimeMode)
				return;

			Block child = target.Children.Where (n => n.IsBlock).Cast<Block> ().FirstOrDefault ();
			isExpression = child != null && child.Type == BlockType.Expression;

			var sb = new StringBuilder ();
			sb.Append (", Tuple.Create<string,object,bool> (");
			sb.WriteCStyleStringLiteral (Prefix.Value);
			sb.Append (", ");

			if (isExpression) {
				oldRenderingMode = context.GetExpressionRenderingMode ();
				context.SetExpressionRenderingMode (ExpressionRenderingMode.InjectCode);
			} else {
				sb.AppendFormat (
					"new {0} ({1} => {{",
					context.Host.GeneratedClassContext.TemplateTypeName,
					ValueWriterName);
			}

			context.MarkEndOfGeneratedCode ();
			context.BufferStatementFragment (sb.ToString ());

			oldTargetWriter = context.TargetWriterName;
			context.TargetWriterName = ValueWriterName;
		}

        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            _writer = context.CreateCodeWriter();

            string prefix = context.BuildCodeString(
                cw => cw.WriteHelperHeaderPrefix(context.Host.GeneratedClassContext.TemplateTypeName, context.Host.StaticHelpers));

            _writer.WriteLinePragma(
                context.GenerateLinePragma(Signature.Location, prefix.Length, Signature.Value.Length));
            _writer.WriteSnippet(prefix);
            _writer.WriteSnippet(Signature);
            if (HeaderComplete)
            {
                _writer.WriteHelperHeaderSuffix(context.Host.GeneratedClassContext.TemplateTypeName);
            }
            _writer.WriteLinePragma(null);
            if (HeaderComplete)
            {
                _writer.WriteReturn();
                _writer.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName);
                _writer.WriteStartLambdaDelegate(HelperWriterName);
            }

            _statementCollectorToken = context.ChangeStatementCollector(AddStatementToHelper);
            _oldWriter = context.TargetWriterName;
            context.TargetWriterName = HelperWriterName;
        }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            // We parsed: "@contentType Text.Html"
            // And we assigned this code generator to the "Text.Html" part
            // So this node's content should be "Text.Html"
            string contentType = target.Content;

            // The final code we want is something like
            // Response.ContentType = ContentTypes.Text.Html;

            // So, we start by injecting the "prolog" (this is compiler speak for the stuff before the user code)
            context.BufferStatementFragment("Response.ContentType = ContentTypes.");

            // Now we tell the code generator infrastructure that we're at the start of user code
            // This allows us to inject markers so the editor can light up.
            context.MarkStartOfGeneratedCode();

            // Here's our user code!
            context.BufferStatementFragment(contentType);

            // And we tell Razor we're finished with user code, again for the editor
            context.MarkEndOfGeneratedCode();

            // Finally, we inject the "epilog" (compiler speak for stuff after the user code)
            context.BufferStatementFragment(";");

            // And output the whole statement to the generated Execute method
            context.FlushBufferedStatement();
        }

        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            if (context.Host.DesignTimeMode)
            {
                return; // Don't generate anything!
            }
            context.FlushBufferedStatement();
            context.AddStatement(context.BuildCodeString(cw =>
            {
                if (!String.IsNullOrEmpty(context.TargetWriterName))
                {
                    cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteAttributeToMethodName);
                    cw.WriteSnippet(context.TargetWriterName);
                    cw.WriteParameterSeparator();
                }
                else
                {
                    cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteAttributeMethodName);
                }
                cw.WriteStringLiteral(Name);
                cw.WriteParameterSeparator();
                cw.WriteLocationTaggedString(Prefix);
                cw.WriteParameterSeparator();
                cw.WriteLocationTaggedString(Suffix);

                // In VB, we need a line continuation
                cw.WriteLineContinuation();
            }));
        }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            // Try to find the namespace in the existing imports
            string ns = Namespace;
            if (!String.IsNullOrEmpty(ns) && Char.IsWhiteSpace(ns[0]))
            {
                ns = ns.Substring(1);
            }

            CodeNamespaceImport import = context.Namespace
                .Imports
                .OfType<CodeNamespaceImport>()
                .Where(i => String.Equals(i.Namespace, ns.Trim(), StringComparison.Ordinal))
                .FirstOrDefault();

            if (import == null)
            {
                // It doesn't exist, create it
                import = new CodeNamespaceImport(ns);
                context.Namespace.Imports.Add(import);
            }

            // Attach our info to the existing/new import.
            import.LinePragma = context.GenerateLinePragma(target);
        }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            context.FlushBufferedStatement();

            string generatedCode = context.BuildCodeString(cw =>
            {
                cw.WriteSnippet(target.Content);
            });

            int startGeneratedCode = target.Start.CharacterIndex;
            generatedCode = Pad(generatedCode, target);

            // Is this the span immediately following "@"?
            if (context.Host.DesignTimeMode &&
                !String.IsNullOrEmpty(generatedCode) &&
                Char.IsWhiteSpace(generatedCode[0]) &&
                target.Previous != null &&
                target.Previous.Kind == SpanKind.Transition &&
                String.Equals(target.Previous.Content, SyntaxConstants.TransitionString))
            {
                generatedCode = generatedCode.Substring(1);
                startGeneratedCode--;
            }

            context.AddStatement(
                generatedCode,
                context.GenerateLinePragma(target, startGeneratedCode));
        }

		public override void GenerateCode (Span target, CodeGeneratorContext context)
		{
			if (context.Host.DesignTimeMode)
				return;

			ExpressionRenderingMode oldMode = context.GetExpressionRenderingMode ();

			var sb = new StringBuilder ();
			sb.Append (", Tuple.Create<string,object,bool> (");
			sb.WriteCStyleStringLiteral (Prefix.Value);
			sb.Append (", ");

			if (ValueGenerator != null) {
				context.SetExpressionRenderingMode (ExpressionRenderingMode.InjectCode);
			} else {
				sb.WriteCStyleStringLiteral (Value);
				sb.Append (", true)");
			}
			context.BufferStatementFragment (sb.ToString ());

			if (ValueGenerator != null) {
				ValueGenerator.Value.GenerateCode (target, context);
				context.FlushBufferedStatement ();
				context.SetExpressionRenderingMode (oldMode);
				context.AddStatement (", false)");
			} else {
				context.FlushBufferedStatement ();
			}
		}

		public override void GenerateEndBlockCode (Block target, CodeGeneratorContext context)
		{
			if (context.Host.DesignTimeMode)
				return;

			context.FlushBufferedStatement ();
			context.AddStatement (");");
		}

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            base.GenerateCode(target, context);

            context.GeneratedClass.UserData.Add("ModelType", this.modelType);
            context.GeneratedClass.BaseTypes.Clear();
            context.GeneratedClass.BaseTypes.Add(new CodeTypeReference(context.Host.DefaultBaseClass, new CodeTypeReference(this.modelType)));
        }

 private void EnsureContextInitialized()
 {
     if (_context == null)
     {
         _context = CodeGeneratorContext.Create(Host, CodeWriterFactory, ClassName, RootNamespaceName, SourceFileName, GenerateLinePragmas);
         Initialize(_context);
     }
 }

 protected override string ResolveType(CodeGeneratorContext context, string baseType)
 {
     return String.Format(
         CultureInfo.InvariantCulture,
         "{0}<{1}>",
         context.Host.DefaultBaseClass,
         baseType);
 }

 /// <summary>
 /// Adds a <see cref="CompiledFromFileAttribute"/> to the <see cref="CodeGeneratorContext.GeneratedClass"/>.
 /// </summary>
 /// <param name="context"></param>
 public override void PostProcessGeneratedCode(CodeGeneratorContext context)
 {
     context.GeneratedClass.CustomAttributes.Add(
         new CodeAttributeDeclaration(
             new CodeTypeReference(typeof(CompiledFromFileAttribute)),
             new CodeAttributeArgument(new CodePrimitiveExpression(context.SourceFile))
         ));
     base.PostProcessGeneratedCode(context);
 }

 protected virtual string ResolveType(CodeGeneratorContext context)
 {
     var modelType = ModelType.Trim();
     if (context.Host.CodeLanguage is VBRazorCodeLanguage)
         return "{0}(Of {1})".FormatWith(context.Host.DefaultBaseClass, modelType);
     if (context.Host.CodeLanguage is CSharpRazorCodeLanguage)
         return "{0}<{1}>".FormatWith(context.Host.DefaultBaseClass, modelType);
     throw new TemplateException("Code language {0} is not supported.".FormatWith(context.Host.CodeLanguage));
 }

 public override void GenerateCode(Span target, CodeGeneratorContext context)
 {
     var attributeType = new CodeTypeReference(typeof(RazorDirectiveAttribute));
     var attributeDeclaration = new CodeAttributeDeclaration(
         attributeType,
         new CodeAttributeArgument(new CodePrimitiveExpression(Name)),
         new CodeAttributeArgument(new CodePrimitiveExpression(Value)));
     context.GeneratedClass.CustomAttributes.Add(attributeDeclaration);
 }

 public override void GenerateCode(Span target, CodeGeneratorContext context)
 {
     Span sourceSpan = null;
     if (context.CreateCodeWriter().SupportsMidStatementLinePragmas || context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
     {
         sourceSpan = target;
     }
     context.BufferStatementFragment(target.Content, sourceSpan);
 }

 public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
 {
     // Flush the buffered statement since we're interrupting it with a comment.
     if (!String.IsNullOrEmpty(context.CurrentBufferedStatement))
     {
         context.MarkEndOfGeneratedCode();
         context.BufferStatementFragment(context.BuildCodeString(cw => cw.WriteLineContinuation()));
     }
     context.FlushBufferedStatement();
 }

 public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
 {
     string startBlock = context.BuildCodeString(cw =>
     {
         cw.WriteEndLambdaDelegate();
         cw.WriteEndMethodInvoke();
         cw.WriteEndStatement();
     });
     context.AddStatement(startBlock);
 }