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)
{
if (Name == SyntaxConstants.CSharp.SessionStateKeyword)
{
context.CodeTreeBuilder.AddSessionStateChunk(Value, target);
}
}
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 void RenderAttributeValue_RendersModelExpressionsCorrectly(string modelExpressionType,
string propertyType,
string expectedValue)
{
// Arrange
var renderer = new MvcTagHelperAttributeValueCodeRenderer(
new GeneratedTagHelperAttributeContext
{
ModelExpressionTypeName = modelExpressionType,
CreateModelExpressionMethodName = "SomeMethod"
});
var attributeDescriptor = new TagHelperAttributeDescriptor("MyAttribute", "SomeProperty", propertyType);
var writer = new CSharpCodeWriter();
var generatorContext = new CodeGeneratorContext(host: null,
className: string.Empty,
rootNamespace: string.Empty,
sourceFile: string.Empty,
shouldGenerateLinePragmas: true);
var errorSink = new ParserErrorSink();
var context = new CodeBuilderContext(generatorContext, errorSink);
// Act
renderer.RenderAttributeValue(attributeDescriptor, writer, context,
(codeWriter) =>
{
codeWriter.Write("MyValue");
},
complexValue: false);
// Assert
Assert.Equal(expectedValue, writer.GenerateCode());
}
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; // 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 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);
}
}
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
var chunk = context.CodeTreeBuilder.StartChunkBlock<HelperChunk>(target, topLevel: true);
chunk.Signature = Signature;
chunk.Footer = Footer;
chunk.HeaderComplete = HeaderComplete;
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
var chunk = context.CodeTreeBuilder.StartChunkBlock<CodeAttributeChunk>(target);
chunk.Attribute = Name;
chunk.Prefix = Prefix;
chunk.Suffix = Suffix;
}
private void EnsureContextInitialized()
{
if (_context == null)
{
_context = CodeGeneratorContext.Create(Host, ClassName, RootNamespaceName, SourceFileName, GenerateLinePragmas);
Initialize(_context);
}
}
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 GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
string startBlock = context.BuildCodeString(cw =>
{
cw.WriteEndLambdaDelegate();
cw.WriteEndMethodInvoke();
cw.WriteEndStatement();
});
context.AddStatement(startBlock);
}
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 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();
}
protected CodeGeneratorContext(CodeGeneratorContext context)
: this(context.Host,
context.ClassName,
context.RootNamespace,
context.SourceFile,
// True because we're pulling from the provided context's source file.
shouldGenerateLinePragmas: true)
{
CodeTreeBuilder = context.CodeTreeBuilder;
}
/// <summary>
/// Starts the generation of a <see cref="TagHelperChunk"/>.
/// </summary>
/// <param name="target">
/// The <see cref="Block"/> responsible for this <see cref="TagHelperCodeGenerator"/>.
/// </param>
/// <param name="context">A <see cref="CodeGeneratorContext"/> instance that contains information about
/// the current code generation process.</param>
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
var tagHelperBlock = target as TagHelperBlock;
if (tagHelperBlock == null)
{
throw new ArgumentException(
RazorResources.TagHelpers_TagHelperCodeGeneartorMustBeAssociatedWithATagHelperBlock);
}
var attributes = new List<KeyValuePair<string, Chunk>>();
// We need to create a code generator to create chunks for each of the attributes.
var codeGenerator = context.Host.CreateCodeGenerator(
context.ClassName,
context.RootNamespace,
context.SourceFile);
foreach (var attribute in tagHelperBlock.Attributes)
{
ChunkBlock attributeChunkValue = null;
if (attribute.Value != null)
{
// Populates the code tree with chunks associated with attributes
attribute.Value.Accept(codeGenerator);
var chunks = codeGenerator.Context.CodeTreeBuilder.CodeTree.Chunks;
var first = chunks.FirstOrDefault();
attributeChunkValue = new ChunkBlock
{
Association = first?.Association,
Children = chunks,
Start = first == null ? SourceLocation.Zero : first.Start
};
}
attributes.Add(new KeyValuePair<string, Chunk>(attribute.Key, attributeChunkValue));
// Reset the code tree builder so we can build a new one for the next attribute
codeGenerator.Context.CodeTreeBuilder = new CodeTreeBuilder();
}
var unprefixedTagName = tagHelperBlock.TagName.Substring(_tagHelperDescriptors.First().Prefix.Length);
context.CodeTreeBuilder.StartChunkBlock(
new TagHelperChunk(
unprefixedTagName,
tagHelperBlock.SelfClosing,
attributes,
_tagHelperDescriptors),
target,
topLevel: false);
}
/// <summary>
/// Generates <see cref="Compiler.AddTagHelperChunk"/>s if <see cref="RemoveTagHelperDescriptors"/> is
/// <c>true</c>, otherwise <see cref="Compiler.RemoveTagHelperChunk"/>s are generated.
/// </summary>
/// <param name="target">
/// The <see cref="Span"/> responsible for this <see cref="AddOrRemoveTagHelperCodeGenerator"/>.
/// </param>
/// <param name="context">A <see cref="CodeGeneratorContext"/> instance that contains information about
/// the current code generation process.</param>
public override void GenerateCode(Span target, CodeGeneratorContext context)
{
if (RemoveTagHelperDescriptors)
{
context.CodeTreeBuilder.AddRemoveTagHelperChunk(LookupText, target);
}
else
{
context.CodeTreeBuilder.AddAddTagHelperChunk(LookupText, target);
}
}
public override void GenerateCode(Span target, CodeGeneratorContext context)
{
var ns = Namespace;
if (!String.IsNullOrEmpty(ns) && Char.IsWhiteSpace(ns[0]))
{
ns = ns.Substring(1);
}
context.CodeTreeBuilder.AddUsingChunk(ns, target);
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
string startBlock = context.BuildCodeString(cw =>
{
cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.DefineSectionMethodName);
cw.WriteStringLiteral(SectionName);
cw.WriteParameterSeparator();
cw.WriteStartLambdaDelegate();
});
context.AddStatement(startBlock);
}
public override void GenerateCode(Span target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
{
return;
}
ExpressionRenderingMode oldMode = context.ExpressionRenderingMode;
context.BufferStatementFragment(context.BuildCodeString(cw =>
{
cw.WriteParameterSeparator();
cw.WriteStartMethodInvoke("Tuple.Create");
cw.WriteLocationTaggedString(Prefix);
cw.WriteParameterSeparator();
if (ValueGenerator != null)
{
cw.WriteStartMethodInvoke("Tuple.Create", "System.Object", "System.Int32");
context.ExpressionRenderingMode = ExpressionRenderingMode.InjectCode;
}
else
{
cw.WriteLocationTaggedString(Value);
cw.WriteParameterSeparator();
// literal: true - This attribute value is a literal value
cw.WriteBooleanLiteral(true);
cw.WriteEndMethodInvoke();
// In VB, we need a line continuation
cw.WriteLineContinuation();
}
}));
if (ValueGenerator != null)
{
ValueGenerator.Value.GenerateCode(target, context);
context.FlushBufferedStatement();
context.ExpressionRenderingMode = oldMode;
context.AddStatement(context.BuildCodeString(cw =>
{
cw.WriteParameterSeparator();
cw.WriteSnippet(ValueGenerator.Location.AbsoluteIndex.ToString(CultureInfo.CurrentCulture));
cw.WriteEndMethodInvoke();
cw.WriteParameterSeparator();
// literal: false - This attribute value is not a literal value, it is dynamically generated
cw.WriteBooleanLiteral(false);
cw.WriteEndMethodInvoke();
// In VB, we need a line continuation
cw.WriteLineContinuation();
}));
}
else
{
context.FlushBufferedStatement();
}
}
public override void GenerateCode(Span target, CodeGeneratorContext context)
{
// Check if the host supports it
if (String.IsNullOrEmpty(context.Host.GeneratedClassContext.ResolveUrlMethodName))
{
// Nope, just use the default MarkupCodeGenerator behavior
new MarkupCodeGenerator().GenerateCode(target, context);
return;
}
context.CodeTreeBuilder.AddResolveUrlChunk(target.Content, target);
}
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
string generatedCode = context.BuildCodeString(cw =>
{
cw.WriteEndLambdaDelegate();
cw.WriteEndConstructor();
cw.WriteEndLambdaExpression();
});
context.BufferStatementFragment(generatedCode);
context.TargetWriterName = _oldTargetWriter;
}
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
{
return; // Don't generate anything!
}
context.FlushBufferedStatement();
context.AddStatement(context.BuildCodeString(cw =>
{
cw.WriteEndMethodInvoke();
cw.WriteEndStatement();
}));
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
string generatedCode = context.BuildCodeString(cw =>
{
cw.WriteStartLambdaExpression(ItemParameterName);
cw.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName);
cw.WriteStartLambdaDelegate(TemplateWriterName);
});
context.MarkEndOfGeneratedCode();
context.BufferStatementFragment(generatedCode);
context.FlushBufferedStatement();
_oldTargetWriter = context.TargetWriterName;
context.TargetWriterName = TemplateWriterName;
}
public override void GenerateCode(Span target, CodeGeneratorContext context)
{
var chunk = context.CodeTreeBuilder.StartChunkBlock<LiteralCodeAttributeChunk>(target);
chunk.Prefix = Prefix;
chunk.Value = Value;
if (ValueGenerator != null)
{
chunk.ValueLocation = ValueGenerator.Location;
ValueGenerator.Value.GenerateCode(target, context);
chunk.ValueLocation = ValueGenerator.Location;
}
context.CodeTreeBuilder.EndChunkBlock();
}
public override void GenerateCode(Span target, CodeGeneratorContext context)
{
context.FlushBufferedStatement();
string generatedCode = context.BuildCodeString(cw =>
{
cw.WriteSnippet(target.Content);
});
int startGeneratedCode = target.Start.CharacterIndex;
int paddingCharCount;
generatedCode = CodeGeneratorPaddingHelper.PadStatement(context.Host, generatedCode, target, ref startGeneratedCode, out paddingCharCount);
context.AddStatement(
generatedCode,
context.GenerateLinePragma(target, paddingCharCount));
}
public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
{
return; // Don't generate anything!
}
// What kind of block is nested within
string generatedCode;
Block child = target.Children.Where(n => n.IsBlock).Cast<Block>().FirstOrDefault();
if (child != null && child.Type == BlockType.Expression)
{
_isExpression = true;
generatedCode = context.BuildCodeString(cw =>
{
cw.WriteParameterSeparator();
cw.WriteStartMethodInvoke("Tuple.Create");
cw.WriteLocationTaggedString(Prefix);
cw.WriteParameterSeparator();
cw.WriteStartMethodInvoke("Tuple.Create", "System.Object", "System.Int32");
});
_oldRenderingMode = context.ExpressionRenderingMode;
context.ExpressionRenderingMode = ExpressionRenderingMode.InjectCode;
}
else
{
generatedCode = context.BuildCodeString(cw =>
{
cw.WriteParameterSeparator();
cw.WriteStartMethodInvoke("Tuple.Create");
cw.WriteLocationTaggedString(Prefix);
cw.WriteParameterSeparator();
cw.WriteStartMethodInvoke("Tuple.Create", "System.Object", "System.Int32");
cw.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName);
cw.WriteStartLambdaDelegate(ValueWriterName);
});
}
context.MarkEndOfGeneratedCode();
context.BufferStatementFragment(generatedCode);
_oldTargetWriter = context.TargetWriterName;
context.TargetWriterName = ValueWriterName;
}
public override void GenerateCode(Span target, CodeGeneratorContext context)
{
string generatedCode = context.BuildCodeString(cw =>
{
cw.WriteSnippet(target.Content);
});
int paddingCharCount;
string paddedCode = CodeGeneratorPaddingHelper.Pad(context.Host, generatedCode, target, out paddingCharCount);
Contract.Assert(paddingCharCount > 0);
context.GeneratedClass.Members.Add(
new CodeSnippetTypeMember(paddedCode)
{
LinePragma = context.GenerateLinePragma(target, paddingCharCount)
});
}
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
if (context.Host.DesignTimeMode)
{
return; // Don't generate anything!
}
string generatedCode;
if (_isExpression)
{
generatedCode = context.BuildCodeString(cw =>
{
cw.WriteParameterSeparator();
cw.WriteSnippet(ValueStart.AbsoluteIndex.ToString(CultureInfo.CurrentCulture));
cw.WriteEndMethodInvoke();
cw.WriteParameterSeparator();
// literal: false - This attribute value is not a literal value, it is dynamically generated
cw.WriteBooleanLiteral(false);
cw.WriteEndMethodInvoke();
cw.WriteLineContinuation();
});
context.ExpressionRenderingMode = _oldRenderingMode;
}
else
{
generatedCode = context.BuildCodeString(cw =>
{
cw.WriteEndLambdaDelegate();
cw.WriteEndConstructor();
cw.WriteParameterSeparator();
cw.WriteSnippet(ValueStart.AbsoluteIndex.ToString(CultureInfo.CurrentCulture));
cw.WriteEndMethodInvoke();
cw.WriteParameterSeparator();
// literal: false - This attribute value is not a literal value, it is dynamically generated
cw.WriteBooleanLiteral(false);
cw.WriteEndMethodInvoke();
cw.WriteLineContinuation();
});
}
context.AddStatement(generatedCode);
context.TargetWriterName = _oldTargetWriter;
}
public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
{
_statementCollectorToken.Dispose();
if (HeaderComplete)
{
_writer.WriteEndLambdaDelegate();
_writer.WriteEndConstructor();
_writer.WriteEndStatement();
}
if (Footer != null && !String.IsNullOrEmpty(Footer.Value))
{
_writer.WriteLinePragma(
context.GenerateLinePragma(Footer.Location, 0, Footer.Value.Length));
_writer.WriteSnippet(Footer);
_writer.WriteLinePragma();
}
_writer.WriteHelperTrailer();
context.GeneratedClass.Members.Add(new CodeSnippetTypeMember(_writer.Content));
context.TargetWriterName = _oldWriter;
}
public override void GenerateCode(Span target, CodeGeneratorContext context)
{
context.CodeTreeBuilder.AddStatementChunk(target.Content, target);
}
