Merge branch 'master' of ..\AspNetCore-Tooling\ into johluo/tooling-soncolidation-source-2

Author: John Luo

src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X/src/CSharpIdentifier.cs

@@ -0,0 +1,76 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X
+{
+    internal static class CSharpIdentifier
+    {
+        private const string CshtmlExtension = ".cshtml";
+
+        public static string GetClassNameFromPath(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                return path;
+            }
+
+            if (path.EndsWith(CshtmlExtension, StringComparison.OrdinalIgnoreCase))
+            {
+                path = path.Substring(0, path.Length - CshtmlExtension.Length);
+            }
+
+            return SanitizeClassName(path);
+        }
+
+        // CSharp Spec §2.4.2
+        private static bool IsIdentifierStart(char character)
+        {
+            return char.IsLetter(character) ||
+                character == '_' ||
+                CharUnicodeInfo.GetUnicodeCategory(character) == UnicodeCategory.LetterNumber;
+        }
+
+        public static bool IsIdentifierPart(char character)
+        {
+            return char.IsDigit(character) ||
+                   IsIdentifierStart(character) ||
+                   IsIdentifierPartByUnicodeCategory(character);
+        }
+
+        private static bool IsIdentifierPartByUnicodeCategory(char character)
+        {
+            var category = CharUnicodeInfo.GetUnicodeCategory(character);
+
+            return category == UnicodeCategory.NonSpacingMark || // Mn
+                category == UnicodeCategory.SpacingCombiningMark || // Mc
+                category == UnicodeCategory.ConnectorPunctuation || // Pc
+                category == UnicodeCategory.Format; // Cf
+        }
+
+        public static string SanitizeClassName(string inputName)
+        {
+            if (string.IsNullOrEmpty(inputName))
+            {
+                return inputName;
+            }
+
+            if (!IsIdentifierStart(inputName[0]) && IsIdentifierPart(inputName[0]))
+            {
+                inputName = "_" + inputName;
+            }
+
+            var builder = new StringBuilder(inputName.Length);
+            for (var i = 0; i < inputName.Length; i++)
+            {
+                var ch = inputName[i];
+                builder.Append(IsIdentifierPart(ch) ? ch : '_');
+            }
+
+            return builder.ToString();
+        }
+    }
+}

src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X/src/ExtensionInitializer.cs

@@ -0,0 +1,29 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.AspNetCore.Razor.Language;
+
+namespace Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X
+{
+    internal class ExtensionInitializer : RazorExtensionInitializer
+    {
+        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);
+            }
+        }
+    }
+}

src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X/src/IInjectTargetExtension.cs

@@ -0,0 +1,12 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.Razor.Language.CodeGeneration;
+
+namespace Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X
+{
+    public interface IInjectTargetExtension : ICodeTargetExtension
+    {
+        void WriteInjectProperty(CodeRenderingContext context, InjectIntermediateNode node);
+    }
+}

src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X/src/IViewComponentTagHelperTargetExtension.cs

@@ -0,0 +1,12 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.Razor.Language.CodeGeneration;
+
+namespace Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X
+{
+    public interface IViewComponentTagHelperTargetExtension : ICodeTargetExtension
+    {
+        void WriteViewComponentTagHelper(CodeRenderingContext context, ViewComponentTagHelperIntermediateNode node);
+    }
+}

src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X/src/InjectDirective.cs

@@ -0,0 +1,124 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.Intermediate;
+
+namespace Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X
+{
+    public static class InjectDirective
+    {
+        public static readonly DirectiveDescriptor Directive = DirectiveDescriptor.CreateDirective(
+            "inject",
+            DirectiveKind.SingleLine,
+            builder =>
+            {
+                builder
+                    .AddTypeToken(Resources.InjectDirective_TypeToken_Name, Resources.InjectDirective_TypeToken_Description)
+                    .AddMemberToken(Resources.InjectDirective_MemberToken_Name, Resources.InjectDirective_MemberToken_Description);
+
+                builder.Usage = DirectiveUsage.FileScopedMultipleOccurring;
+                builder.Description = Resources.InjectDirective_Description;
+            });
+
+        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;
+        }
+
+        internal class Pass : IntermediateNodePassBase, IRazorDirectiveClassifierPass
+        {
+            // Runs after the @model and @namespace directives
+            public override int Order => 10;
+            
+            protected override void ExecuteCore(RazorCodeDocument codeDocument, DocumentIntermediateNode documentNode)
+            {
+                var visitor = new Visitor();
+                visitor.Visit(documentNode);
+                var modelType = ModelDirective.GetModelType(documentNode);
+
+                var properties = new HashSet<string>(StringComparer.Ordinal);
+
+                for (var i = visitor.Directives.Count - 1; i >= 0; i--)
+                {
+                    var directive = visitor.Directives[i];
+                    var tokens = directive.Tokens.ToArray();
+                    if (tokens.Length < 2)
+                    {
+                        continue;
+                    }
+
+                    var typeName = tokens[0].Content;
+                    var memberName = tokens[1].Content;
+
+                    if (!properties.Add(memberName))
+                    {
+                        continue;
+                    }
+
+                    typeName = typeName.Replace("<TModel>", "<" + modelType + ">");
+
+                    var injectNode = new InjectIntermediateNode()
+                    {
+                        TypeName = typeName,
+                        MemberName = memberName,
+                    };
+
+                    visitor.Class.Children.Add(injectNode);
+                }
+            }
+        }
+
+        private class Visitor : IntermediateNodeWalker
+        {
+            public ClassDeclarationIntermediateNode Class { get; private set; }
+
+            public IList<DirectiveIntermediateNode> Directives { get; } = new List<DirectiveIntermediateNode>();
+
+            public override void VisitClassDeclaration(ClassDeclarationIntermediateNode node)
+            {
+                if (Class == null)
+                {
+                    Class = node;
+                }
+
+                base.VisitClassDeclaration(node);
+            }
+
+            public override void VisitDirective(DirectiveIntermediateNode node)
+            {
+                if (node.Directive == Directive)
+                {
+                    Directives.Add(node);
+                }
+            }
+        }
+
+        #region Obsolete
+        [Obsolete("This method is obsolete and will be removed in a future version.")]
+        public static IRazorEngineBuilder Register(IRazorEngineBuilder builder)
+        {
+            if (builder == null)
+            {
+                throw new ArgumentNullException(nameof(builder));
+            }
+
+            builder.AddDirective(Directive);
+            builder.Features.Add(new Pass());
+            builder.AddTargetExtension(new InjectTargetExtension());
+            return builder;
+        }
+        #endregion
+    }
+}

src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X/src/InjectIntermediateNode.cs

@@ -0,0 +1,59 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.CodeGeneration;
+using Microsoft.AspNetCore.Razor.Language.Intermediate;
+
+namespace Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X
+{
+    public class InjectIntermediateNode : ExtensionIntermediateNode
+    {
+        public string TypeName { get; set; }
+
+        public string MemberName { get; set; }
+
+        public override IntermediateNodeCollection Children => IntermediateNodeCollection.ReadOnly;
+
+        public override void Accept(IntermediateNodeVisitor visitor)
+        {
+            if (visitor == null)
+            {
+                throw new ArgumentNullException(nameof(visitor));
+            }
+
+            AcceptExtensionNode<InjectIntermediateNode>(this, visitor);
+        }
+
+        public override void WriteNode(CodeTarget target, CodeRenderingContext context)
+        {
+            if (target == null)
+            {
+                throw new ArgumentNullException(nameof(target));
+            }
+
+            if (context == null)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
+            var extension = target.GetExtension<IInjectTargetExtension>();
+            if (extension == null)
+            {
+                ReportMissingCodeTargetExtension<IInjectTargetExtension>(context);
+                return;
+            }
+
+            extension.WriteInjectProperty(context, this);
+        }
+
+        public override void FormatNode(IntermediateNodeFormatter formatter)
+        {
+            formatter.WriteContent(MemberName);
+
+            formatter.WriteProperty(nameof(MemberName), MemberName);
+            formatter.WriteProperty(nameof(TypeName), TypeName);
+        }
+    }
+}

src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X/src/InjectTargetExtension.cs

@@ -0,0 +1,44 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.AspNetCore.Razor.Language.CodeGeneration;
+
+namespace Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X
+{
+    public class InjectTargetExtension : IInjectTargetExtension
+    {
+        private const string RazorInjectAttribute = "[global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute]";
+
+        public void WriteInjectProperty(CodeRenderingContext context, InjectIntermediateNode node)
+        {
+            if (context == null)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
+            if (node == null)
+            {
+                throw new ArgumentNullException(nameof(node));
+            }
+
+            var property = $"public {node.TypeName} {node.MemberName} {{ get; private set; }}";
+
+            if (node.Source.HasValue)
+            {
+                using (context.CodeWriter.BuildLinePragma(node.Source.Value, context))
+                {
+                    context.CodeWriter
+                        .WriteLine(RazorInjectAttribute)
+                        .WriteLine(property);
+                }
+            }
+            else
+            {
+                context.CodeWriter
+                    .WriteLine(RazorInjectAttribute)
+                    .WriteLine(property);
+            }
+        }
+    }
+}

src/Razor/Microsoft.AspNetCore.Mvc.Razor.Extensions.Version1_X/src/LegacySectionTargetExtension.cs

@@ -0,0 +1,32 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.Razor.Language.CodeGeneration;
+
+namespace Microsoft.AspNetCore.Razor.Language.Extensions
+{
+    internal class LegacySectionTargetExtension : ISectionTargetExtension
+    {
+        private static readonly string DefaultWriterName = "__razor_section_writer";
+
+        public static readonly string DefaultSectionMethodName = "DefineSection";
+
+        public string SectionMethodName { get; set; } = DefaultSectionMethodName;
+
+        public void WriteSection(CodeRenderingContext context, SectionIntermediateNode node)
+        {
+            context.CodeWriter
+                .WriteStartMethodInvocation(SectionMethodName)
+                .Write("\"")
+                .Write(node.SectionName)
+                .Write("\", ");
+
+            using (context.CodeWriter.BuildAsyncLambda(DefaultWriterName))
+            {
+                context.RenderChildren(node);
+            }
+
+            context.CodeWriter.WriteEndMethodInvocation(endLine: true);
+        }
+    }
+}