/// <summary>
/// Sets the root namespace for the generated code.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="rootNamespace">The root namespace.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder SetRootNamespace(this RazorProjectEngineBuilder builder, string rootNamespace)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Features.Add(new ConfigureRootNamespaceFeature(rootNamespace));
return(builder);
}
/// <summary>
/// Sets the SupportLocalizedComponentNames property to make localized component name diagnostics available.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder SetSupportLocalizedComponentNames(this RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Features.Add(new SetSupportLocalizedComponentNamesFeature());
return(builder);
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(Directive, FileKinds.Component, FileKinds.ComponentImport);
builder.Features.Add(new ComponentLayoutDirectivePass());
}
public static RazorProjectEngineBuilder Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(Directive, FileKinds.Legacy, FileKinds.Component, FileKinds.ComponentImport);
return(builder);
}
public static RazorProjectEngineBuilder Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(Directive);
return(builder);
}
public static void RegisterViewComponentTagHelpers(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Features.Add(new ViewComponentTagHelperPass());
builder.AddTargetExtension(new ViewComponentTagHelperTargetExtension());
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(Directive);
builder.Features.Add(new InheritsDirectivePass());
}
/// <summary>
/// Registers the Blazor extension.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
FunctionsDirective.Register(builder);
ImplementsDirective.Register(builder);
InheritsDirective.Register(builder);
InjectDirective.Register(builder);
LayoutDirective.Register(builder);
PageDirective.Register(builder);
builder.Features.Remove(builder.Features.OfType <IImportProjectFeature>().Single());
builder.Features.Add(new BlazorImportProjectFeature());
var index = builder.Phases.IndexOf(builder.Phases.OfType <IRazorCSharpLoweringPhase>().Single());
builder.Phases[index] = new BlazorRazorCSharpLoweringPhase();
builder.Features.Add(new ConfigureBlazorCodeGenerationOptions());
var isDeclarationOnlyCompile = builder.Configuration.ConfigurationName == DeclarationConfiguration.ConfigurationName;
// Blazor-specific passes, in order.
if (!isDeclarationOnlyCompile)
{
// There's no benefit in this optimization during the declaration-only compile
builder.Features.Add(new TrimWhitespacePass());
}
builder.Features.Add(new ComponentDocumentClassifierPass());
builder.Features.Add(new ComponentDocumentRewritePass());
builder.Features.Add(new ScriptTagPass());
builder.Features.Add(new ComplexAttributeContentPass());
builder.Features.Add(new ComponentLoweringPass());
builder.Features.Add(new EventHandlerLoweringPass());
builder.Features.Add(new RefLoweringPass());
builder.Features.Add(new BindLoweringPass());
// Temporarily disabled for 0.5.1
// builder.Features.Add(new HtmlBlockPass());
builder.Features.Add(new ComponentTagHelperDescriptorProvider());
builder.Features.Add(new BindTagHelperDescriptorProvider());
builder.Features.Add(new EventHandlerTagHelperDescriptorProvider());
builder.Features.Add(new RefTagHelperDescriptorProvider());
if (isDeclarationOnlyCompile)
{
// This is for 'declaration only' processing. We don't want to try and emit any method bodies during
// the design time build because we can't do it correctly until the set of components is known.
builder.Features.Add(new EliminateMethodBodyPass());
}
}
/// <summary>
/// Adds the provided <see cref="RazorProjectItem" />s as imports to all project items processed
/// by the <see cref="RazorProjectEngine"/>.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="imports">The collection of imports.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder AddDefaultImports(this RazorProjectEngineBuilder builder, params string[] imports)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Features.Add(new AdditionalImportsProjectFeature(imports));
return(builder);
}
public static RazorProjectEngineBuilder Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(FileKinds.Component, Directive);
builder.Features.Add(new ComponentPageDirectivePass());
return(builder);
}
private void ConfigureProjectEngine(RazorProjectEngineBuilder builder)
{
var projectSnapshot = _documentTracker.ProjectSnapshot;
if (projectSnapshot != null)
{
builder.SetCSharpLanguageVersion(projectSnapshot.CSharpLanguageVersion);
}
builder.SetRootNamespace(projectSnapshot?.RootNamespace);
builder.Features.Add(new VisualStudioParserOptionsFeature(_documentTracker.EditorSettings));
builder.Features.Add(new VisualStudioTagHelperFeature(_documentTracker.TagHelpers));
}
public static RazorProjectEngineBuilder Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(Directive);
builder.Features.Add(new Pass(builder.Configuration.DesignTime));
return(builder);
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(Directive, FileKinds.Legacy, FileKinds.Component);
builder.Features.Add(new SectionDirectivePass());
builder.AddTargetExtension(new SectionTargetExtension());
}
private static DefaultRazorDirectiveFeature GetDirectiveFeature(RazorProjectEngineBuilder builder)
{
var directiveFeature = builder.Features.OfType <DefaultRazorDirectiveFeature>().FirstOrDefault();
if (directiveFeature == null)
{
directiveFeature = new DefaultRazorDirectiveFeature();
builder.Features.Add(directiveFeature);
}
return(directiveFeature);
}
private static IRazorTargetExtensionFeature GetTargetExtensionFeature(RazorProjectEngineBuilder builder)
{
var targetExtensionFeature = builder.Features.OfType <IRazorTargetExtensionFeature>().FirstOrDefault();
if (targetExtensionFeature == null)
{
targetExtensionFeature = new DefaultRazorTargetExtensionFeature();
builder.Features.Add(targetExtensionFeature);
}
return(targetExtensionFeature);
}
public static RazorProjectEngineBuilder Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(Directive);
builder.Features.Add(new Pass());
builder.AddTargetExtension(new InjectTargetExtension());
return(builder);
}
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.AddDirective(InternalDirective, FileKinds.Legacy, FileKinds.Component, FileKinds.ComponentImport);
builder.AddDirective(PrivateDirective, FileKinds.Legacy, FileKinds.Component, FileKinds.ComponentImport);
builder.AddDirective(PublicDirective, FileKinds.Legacy, FileKinds.Component, FileKinds.ComponentImport);
builder.Features.Add(new AccessibilityModificatorDirectivesPass());
}
/// <summary>
/// Sets the namespace for generated types.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="namespaceName">The name of the namespace.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder SetNamespace(this RazorProjectEngineBuilder builder, string namespaceName)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var configurationFeature = GetDefaultDocumentClassifierPassFeature(builder);
configurationFeature.ConfigureNamespace.Add((document, @namespace) => @namespace.Content = namespaceName);
return(builder);
}
/// <summary>
/// Sets the base type for generated types.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="baseType">The name of the base type.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder SetBaseType(this RazorProjectEngineBuilder builder, string baseType)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var configurationFeature = GetDefaultDocumentClassifierPassFeature(builder);
configurationFeature.ConfigureClass.Add((document, @class) => @class.BaseType = baseType);
return(builder);
}
public static RazorProjectEngineBuilder AddTagHelpers(this RazorProjectEngineBuilder builder, IEnumerable <TagHelperDescriptor> tagHelpers)
{
var feature = (TestTagHelperFeature)builder.Features.OfType <ITagHelperFeature>().FirstOrDefault();
if (feature == null)
{
feature = new TestTagHelperFeature();
builder.Features.Add(feature);
}
feature.TagHelpers.AddRange(tagHelpers);
return(builder);
}
public static void Register(RazorProjectEngineBuilder builder)
{
var defaultRazorCSharpLoweringPhase = builder.Phases.SingleOrDefault(x => x.GetType() == Type.GetType("Microsoft.AspNetCore.Razor.Language.DefaultRazorCSharpLoweringPhase, Microsoft.AspNetCore.Razor.Language"));
if (defaultRazorCSharpLoweringPhase == null)
{
throw new RazorLightException("SetTemplateTypePhase cannot be registered as DefaultRazorCSharpLoweringPhase could not be located");
}
// This phase needs to run just before DefaultRazorCSharpLoweringPhase
var phaseIndex = builder.Phases.IndexOf(defaultRazorCSharpLoweringPhase);
builder.Phases.Insert(phaseIndex, new OverrideRuntimeNodeWriterTemplateTypeNamePhase("global::RazorLight.Razor.RazorLightHelperResult"));
}
private static void LoadExtensions(RazorProjectEngineBuilder builder, IReadOnlyList <RazorExtension> extensions)
{
for (var i = 0; i < extensions.Count; i++)
{
// For now we only handle AssemblyExtension - which is not user-constructable. We're keeping a tight
// lid on how things work until we add official support for extensibility everywhere. So, this is
// intentionally inflexible for the time being.
if (extensions[i] is AssemblyExtension extension)
{
var initializer = extension.CreateInitializer();
initializer?.Initialize(builder);
}
}
}
private static void AddComponentFeatures(RazorProjectEngineBuilder builder, RazorLanguageVersion razorLanguageVersion)
{
// Project Engine Features
builder.Features.Add(new ComponentImportProjectFeature());
// Directives (conditional on file kind)
ComponentCodeDirective.Register(builder);
ComponentInjectDirective.Register(builder);
ComponentLayoutDirective.Register(builder);
ComponentPageDirective.Register(builder);
if (razorLanguageVersion.CompareTo(RazorLanguageVersion.Version_6_0) >= 0)
{
ComponentConstrainedTypeParamDirective.Register(builder);
}
else
{
ComponentTypeParamDirective.Register(builder);
}
if (razorLanguageVersion.CompareTo(RazorLanguageVersion.Version_5_0) >= 0)
{
ComponentPreserveWhitespaceDirective.Register(builder);
}
// Document Classifier
builder.Features.Add(new ComponentDocumentClassifierPass());
// Directive Classifier
builder.Features.Add(new ComponentWhitespacePass());
// Optimization
builder.Features.Add(new ComponentComplexAttributeContentPass());
builder.Features.Add(new ComponentLoweringPass());
builder.Features.Add(new ComponentScriptTagPass());
builder.Features.Add(new ComponentEventHandlerLoweringPass());
builder.Features.Add(new ComponentKeyLoweringPass());
builder.Features.Add(new ComponentReferenceCaptureLoweringPass());
builder.Features.Add(new ComponentSplatLoweringPass());
builder.Features.Add(new ComponentBindLoweringPass());
builder.Features.Add(new ComponentCssScopePass());
builder.Features.Add(new ComponentTemplateDiagnosticPass());
builder.Features.Add(new ComponentGenericTypePass());
builder.Features.Add(new ComponentChildContentDiagnosticPass());
builder.Features.Add(new ComponentMarkupDiagnosticPass());
builder.Features.Add(new ComponentMarkupBlockPass());
builder.Features.Add(new ComponentMarkupEncodingPass());
}
public override void Initialize(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (builder.Configuration.ConfigurationName == "MVC-1.0")
{
RazorExtensions.Register(builder);
}
else if (builder.Configuration.ConfigurationName == "MVC-1.1")
{
RazorExtensions.Register(builder);
RazorExtensions.RegisterViewComponentTagHelpers(builder);
}
}
/// <summary>
/// Registers built-in Razor features that require a reference to <c>Microsoft.CodeAnalysis.CSharp</c>.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
public static void Register(RazorProjectEngineBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (builder.Configuration.LanguageVersion.CompareTo(RazorLanguageVersion.Version_3_0) >= 0)
{
builder.Features.Add(new BindTagHelperDescriptorProvider());
builder.Features.Add(new ComponentTagHelperDescriptorProvider());
builder.Features.Add(new EventHandlerTagHelperDescriptorProvider());
builder.Features.Add(new RefTagHelperDescriptorProvider());
builder.Features.Add(new DefaultTypeNameFeature());
}
}
public static void Register(RazorProjectEngineBuilder builder)
{
var defaultRazorCSharpLoweringPhase = builder.Phases.SingleOrDefault(x =>
{
var type = x.GetType();
var assemblyQualifiedNameOfTypeWeCareAbout = "Microsoft.AspNetCore.Razor.Language.DefaultRazorCSharpLoweringPhase, Microsoft.AspNetCore.Razor.Language, ";
return(type.AssemblyQualifiedName.Substring(0,
assemblyQualifiedNameOfTypeWeCareAbout.Length) == assemblyQualifiedNameOfTypeWeCareAbout);
});
TkDebug.AssertNotNull(defaultRazorCSharpLoweringPhase,
"SetTemplateTypePhase cannot be registered as DefaultRazorCSharpLoweringPhase could not be located", null);
// This phase needs to run just before DefaultRazorCSharpLoweringPhase
var phaseIndex = builder.Phases.IndexOf(defaultRazorCSharpLoweringPhase);
builder.Phases.Insert(phaseIndex, new OverrideRuntimeNodeWriterTemplateTypeNamePhase("global::RazorLight.Razor.RazorLightHelperResult"));
}
/// <summary>
/// Sets the C# language version to target when generating code.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="csharpLanguageVersion">The C# <see cref="LanguageVersion"/>.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder SetCSharpLanguageVersion(this RazorProjectEngineBuilder builder, LanguageVersion csharpLanguageVersion)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var existingFeature = builder.Features.OfType <ConfigureParserForCSharpVersionFeature>().FirstOrDefault();
if (existingFeature != null)
{
builder.Features.Remove(existingFeature);
}
builder.Features.Add(new ConfigureParserForCSharpVersionFeature(csharpLanguageVersion));
return(builder);
}
/// <summary>
/// Adds the specified <see cref="ICodeTargetExtension"/>.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="extension">The <see cref="ICodeTargetExtension"/> to add.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder AddTargetExtension(this RazorProjectEngineBuilder builder, ICodeTargetExtension extension)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (extension == null)
{
throw new ArgumentNullException(nameof(extension));
}
var targetExtensionFeature = GetTargetExtensionFeature(builder);
targetExtensionFeature.TargetExtensions.Add(extension);
return(builder);
}
/// <summary>
/// Adds the specified <see cref="DirectiveDescriptor"/>.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="directive">The <see cref="DirectiveDescriptor"/> to add.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder AddDirective(this RazorProjectEngineBuilder builder, DirectiveDescriptor directive)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (directive == null)
{
throw new ArgumentNullException(nameof(directive));
}
var directiveFeature = GetDirectiveFeature(builder);
directiveFeature.Directives.Add(directive);
return(builder);
}
/// <summary>
/// Registers a class configuration delegate that gets invoked during code generation.
/// </summary>
/// <param name="builder">The <see cref="RazorProjectEngineBuilder"/>.</param>
/// <param name="configureClass"><see cref="Action"/> invoked to configure
/// <see cref="ClassDeclarationIntermediateNode"/> during code generation.</param>
/// <returns>The <see cref="RazorProjectEngineBuilder"/>.</returns>
public static RazorProjectEngineBuilder ConfigureClass(
this RazorProjectEngineBuilder builder,
Action <RazorCodeDocument, ClassDeclarationIntermediateNode> configureClass)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configureClass == null)
{
throw new ArgumentNullException(nameof(configureClass));
}
var configurationFeature = GetDefaultDocumentClassifierPassFeature(builder);
configurationFeature.ConfigureClass.Add(configureClass);
return(builder);
}
