// internal for unit testing only, not intended to be used directly in code
        internal static int CalculatePadding(RazorEngineHost host, Span target, int generatedStart)
        {
            if (host == null)
            {
                throw new ArgumentNullException("host");
            }

            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            int padding;

            padding = CollectSpacesAndTabs(target, host.TabSize) - generatedStart;

            // if we add generated text that is longer than the padding we wanted to insert we have no recourse and we have to skip padding
            // example:
            // Razor code at column zero: @somecode()
            // Generated code will be:
            // In design time: __o = somecode();
            // In Run time: Write(somecode());
            //
            // In both cases the padding would have been 1 space to remote the space the @ symbol takes, which will be smaller than the 6 chars the hidden generated code takes.
            if (padding < 0)
            {
                padding = 0;
            }

            return padding;
        }

 public CodeBlockInfo(string name, SourceLocation start, bool isTopLevel, Span transitionSpan, Span initialSpan) {
     Name = name;
     Start = start;
     IsTopLevel = isTopLevel;
     TransitionSpan = transitionSpan;
     InitialSpan = initialSpan;
 }

 public virtual bool OwnsChange(Span target, TextChange change)
 {
     int end = target.Start.AbsoluteIndex + target.Length;
     int changeOldEnd = change.OldPosition + change.OldLength;
     return change.OldPosition >= target.Start.AbsoluteIndex &&
            (changeOldEnd < end || (changeOldEnd == end && AcceptedCharacters != AcceptedCharacters.None));
 }

		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 IEnumerable<Node> Parse(Span span)
 {
     return new[]
     {
         new ExpressionNode(span.Content)
     };
 }

        protected override bool TryVisitSpecialSpan(Span span)
        {
            var vistors = (Vistors ?? Enumerable.Empty<CSharpRazorCodeGeneratorSpanVisitor>());

            return base.TryVisitSpecialSpan(span)
                || vistors.FirstOrDefault(x => x.TryVisit(span)) != null;
        }

        // Special case for statement padding to account for brace positioning in the editor.
        public static string PadStatement(RazorEngineHost host, string code, Span target, ref int startGeneratedCode, out int paddingCharCount)
        {
            if (host == null)
            {
                throw new ArgumentNullException("host");
            }

            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            // We are passing 0 rather than startgeneratedcode intentionally (keeping v2 behavior).
            int padding = CalculatePadding(host, target, 0);

            // We treat statement padding specially so for brace positioning, so that in the following example:
            //   @if (foo > 0)
            //   {
            //   }
            //
            // the braces shows up under the @ rather than under the if.
            if (host.DesignTimeMode &&
                padding > 0 &&
                target.Previous.Kind == SpanKind.Transition && // target.Previous is guaranteed to be none null if you got any padding.
                String.Equals(target.Previous.Content, SyntaxConstants.TransitionString))
            {
                padding--;
                startGeneratedCode--;
            }

            string generatedCode = PadInternal(host, code, padding, out paddingCharCount);

            return generatedCode;
        }

        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 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)
        {
            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)));
        }

 public SpanBuilder(Span original)
 {
     Kind = original.Kind;
     _symbols = new List<ISymbol>(original.Symbols);
     EditHandler = original.EditHandler;
     CodeGenerator = original.CodeGenerator;
     Start = original.Start;
 }

 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);
 }

 protected internal static int CalculatePadding(Span target, int generatedStart)
 {
     int padding = target.Start.CharacterIndex - generatedStart;
     if (padding < 0)
     {
         padding = 0;
     }
     return padding;
 }

 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);
 }

		protected override SyntaxTreeNode RewriteSpan (BlockBuilder parent, Span span)
		{
			var b = new SpanBuilder (span);
			var old = (LiteralAttributeCodeGenerator)span.CodeGenerator;
			b.CodeGenerator = old.ValueGenerator != null
				? new PreprocessedLiteralAttributeCodeGenerator (old.Prefix, old.ValueGenerator)
				: new PreprocessedLiteralAttributeCodeGenerator (old.Prefix, old.Value);
			return b.Build ();
		}

		void VisitModelNameSpan(Span span)
		{
			if (span == null)
				return;
			
			string firstLineOfMarkup = GetFirstLine(span.Content);
			ModelTypeName = firstLineOfMarkup.Trim();
			foundModelTypeName = true;
		}

 public override void GenerateCode(Span target, CodeGeneratorContext context)
 {
     if (!context.Host.DesignTimeMode && !String.IsNullOrEmpty(context.Host.GeneratedClassContext.LayoutPropertyName))
     {
         context.TargetMethod.Statements.Add(
             new CodeAssignStatement(
                 new CodePropertyReferenceExpression(null, context.Host.GeneratedClassContext.LayoutPropertyName),
                 new CodePrimitiveExpression(LayoutPath)));
     }
 }

  public override void VisitSpan(Span span)
  {
      if (span.Kind == SpanKind.Markup && !m_DebugStatusReader.IsDebuggingEnabled())
      {
          string content = span.Content;
          span.Content = m_HtmPagelMinifier.Minify(content, true, true);
      }
 
      base.VisitSpan(span);
  }

        public void CalculatePaddingForEmptySpanReturnsZero()
        {
            RazorEngineHost host = CreateHost(designTime: true);

            Span span = new Span(new SpanBuilder());

            int padding = CodeGeneratorPaddingHelper.CalculatePadding(host, span, 0);

            Assert.Equal(0, padding);
        }