Merge pull request #12 from sharwell/framework

sharwell · sharwell · commit 17115f88e293 · 2015-05-03T15:50:21.000-07:00
Framework
diff --git a/AsyncUsageAnalyzers/AsyncUsageAnalyzers/AnalyzerConstants.cs b/AsyncUsageAnalyzers/AsyncUsageAnalyzers/AnalyzerConstants.cs
@@ -0,0 +1,29 @@
+﻿namespace AsyncUsageAnalyzers
+{
+    using Microsoft.CodeAnalysis;
+
+    internal static class AnalyzerConstants
+    {
+        static AnalyzerConstants()
+        {
+#if DEBUG
+            // In DEBUG builds, the tests are enabled to simplify development and testing.
+            DisabledNoTests = true;
+#else
+            DisabledNoTests = false;
+#endif
+        }
+
+        /// <summary>
+        /// Gets a reference value which can be passed to
+        /// <see cref="DiagnosticDescriptor(string, string, string, string, DiagnosticSeverity, bool, string, string, string[])"/>
+        /// to disable a diagnostic which is currently untested.
+        /// </summary>
+        /// <value>
+        /// A reference value which can be passed to
+        /// <see cref="DiagnosticDescriptor(string, string, string, string, DiagnosticSeverity, bool, string, string, string[])"/>
+        /// to disable a diagnostic which is currently untested.
+        /// </value>
+        internal static bool DisabledNoTests { get; }
+    }
+}
diff --git a/AsyncUsageAnalyzers/AsyncUsageAnalyzers/AnalyzerExtensions.cs b/AsyncUsageAnalyzers/AsyncUsageAnalyzers/AnalyzerExtensions.cs
@@ -0,0 +1,50 @@
+﻿// This file originally obtained from 
+// https://github.com/code-cracker/code-cracker/blob/08c1a01337964924eeed12be8b14c8ce8ec6b626/src/Common/CodeCracker.Common/Extensions/AnalyzerExtensions.cs
+// It is subject to the Apache License 2.0
+// This file has been modified since obtaining it from its original source.
+
+namespace AsyncUsageAnalyzers
+{
+    using System;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    internal static class AnalyzerExtensions
+    {
+        internal static void RegisterSyntaxTreeActionHonorExclusions(this AnalysisContext context, Action<SyntaxTreeAnalysisContext> action)
+        {
+            context.RegisterSyntaxTreeAction(
+                c =>
+                {
+                    if (c.IsGeneratedDocument())
+                    {
+                        return;
+                    }
+
+                    // Honor the containing document item's ExcludeFromStylecop=True
+                    // MSBuild metadata, if analyzers have access to it.
+                    //// TODO: code here
+
+                    action(c);
+                });
+        }
+
+        internal static void RegisterSyntaxNodeActionHonorExclusions<TLanguageKindEnum>(this AnalysisContext context, Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds) where TLanguageKindEnum : struct
+        {
+            context.RegisterSyntaxNodeAction(
+                c =>
+                {
+                    if (c.IsGenerated())
+                    {
+                        return;
+                    }
+
+                    // Honor the containing document item's ExcludeFromStylecop=True
+                    // MSBuild metadata, if analyzers have access to it.
+                    //// TODO: code here
+
+                    action(c);
+                },
+                syntaxKinds);
+        }
+    }
+}
diff --git a/AsyncUsageAnalyzers/AsyncUsageAnalyzers/AsyncUsageAnalyzers.csproj b/AsyncUsageAnalyzers/AsyncUsageAnalyzers/AsyncUsageAnalyzers.csproj
@@ -42,6 +42,11 @@
     <AssemblyOriginatorKeyFile Condition="'$(KeyConfiguration)' != 'Final'">..\..\build\keys\AsyncUsageAnalyzers.dev.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="AnalyzerConstants.cs" />
+    <Compile Include="AnalyzerExtensions.cs" />
+    <Compile Include="GeneratedCodeAnalysisExtensions.cs" />
+    <Compile Include="Helpers\RenameHelper.cs" />
+    <Compile Include="NoCodeFixAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Resources.Designer.cs">
       <AutoGen>True</AutoGen>
diff --git a/AsyncUsageAnalyzers/AsyncUsageAnalyzers/GeneratedCodeAnalysisExtensions.cs b/AsyncUsageAnalyzers/AsyncUsageAnalyzers/GeneratedCodeAnalysisExtensions.cs
@@ -0,0 +1,187 @@
+﻿// This file originally obtained from 
+// https://raw.githubusercontent.com/code-cracker/code-cracker/08c1a01337964924eeed12be8b14c8ce8ec6b626/src/Common/CodeCracker.Common/Extensions/GeneratedCodeAnalysisExtensions.cs
+// It is subject to the Apache License 2.0
+// This file has been modified since obtaining it from its original source.
+
+namespace AsyncUsageAnalyzers
+{
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.CompilerServices;
+    using System.Text.RegularExpressions;
+    using System.Threading;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    internal static class GeneratedCodeAnalysisExtensions
+    {
+        /// <summary>
+        /// A cache of the result of computing whether a document has an auto-generated header.
+        /// </summary>
+        /// <remarks>
+        /// This allows many analyzers that run on every token in the file to avoid checking
+        /// the same state in the document repeatedly.
+        /// </remarks>
+        private static readonly ConditionalWeakTable<SyntaxTree, StrongBox<bool?>> GeneratedHeaderPresentCheck
+            = new ConditionalWeakTable<SyntaxTree, StrongBox<bool?>>();
+
+        /// <summary>
+        /// Checks whether the given node or its containing document is auto generated by a tool.
+        /// </summary>
+        /// <remarks>
+        /// <para>This method uses <see cref="IsGeneratedDocument(SyntaxTree, CancellationToken)"/> to determine which
+        /// code is considered "generated".</para>
+        /// </remarks>
+        /// <param name="context">The analysis context for a <see cref="SyntaxNode"/>.</param>
+        /// <returns>
+        /// <para><see langword="true"/> if the <see cref="SyntaxNode"/> contained in <paramref name="context"/> is
+        /// located in generated code; otherwise, <see langword="false"/>.</para>
+        /// </returns>
+        internal static bool IsGenerated(this SyntaxNodeAnalysisContext context)
+        {
+            return IsGeneratedDocument(context.Node.SyntaxTree, context.CancellationToken);
+        }
+
+        /// <summary>
+        /// Checks whether the given document is auto generated by a tool.
+        /// </summary>
+        /// <remarks>
+        /// <para>This method uses <see cref="IsGeneratedDocument(SyntaxTree, CancellationToken)"/> to determine which
+        /// code is considered "generated".</para>
+        /// </remarks>
+        /// <param name="context">The analysis context for a <see cref="SyntaxTree"/>.</param>
+        /// <returns>
+        /// <para><see langword="true"/> if the <see cref="SyntaxTree"/> contained in <paramref name="context"/> is
+        /// located in generated code; otherwise, <see langword="false"/>.</para>
+        /// </returns>
+        internal static bool IsGeneratedDocument(this SyntaxTreeAnalysisContext context)
+        {
+            return IsGeneratedDocument(context.Tree, context.CancellationToken);
+        }
+
+        /// <summary>
+        /// Checks whether the given document is auto generated by a tool
+        /// (based on filename or comment header).
+        /// </summary>
+        /// <remarks>
+        /// <para>The exact conditions used to identify generated code are subject to change in future releases. The current algorithm uses the following checks.</para>
+        /// <para>Code is considered generated if it meets any of the following conditions.</para>
+        /// <list type="bullet">
+        /// <item>The code is contained in a file which starts with a comment containing the text
+        /// <c>&lt;auto-generated</c>.</item>
+        /// <item>The code is contained in a file with a name matching certain patterns (case-insensitive):
+        /// <list type="bullet">
+        /// <item>service.cs</item>
+        /// <item>TemporaryGeneratedFile_*.cs</item>
+        /// <item>assemblyinfo.cs</item>
+        /// <item>assemblyattributes.cs</item>
+        /// <item>*.g.cs</item>
+        /// <item>*.g.i.cs</item>
+        /// <item>*.designer.cs</item>
+        /// <item>*.generated.cs</item>
+        /// <item>*.assemblyattributes.cs</item>
+        /// </list>
+        /// </item>
+        /// </list>
+        /// </remarks>
+        /// <param name="tree">The syntax tree to examine.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
+        /// <returns>
+        /// <para><see langword="true"/> if <paramref name="tree"/> is located in generated code; otherwise,
+        /// <see langword="false"/>. If <paramref name="tree"/> is <see langword="null"/>, this method returns
+        /// <see langword="false"/>.</para>
+        /// </returns>
+        public static bool IsGeneratedDocument(this SyntaxTree tree, CancellationToken cancellationToken)
+        {
+            if (tree == null)
+            {
+                return false;
+            }
+
+            StrongBox<bool?> cachedResult = GeneratedHeaderPresentCheck.GetOrCreateValue(tree);
+            if (cachedResult.Value.HasValue)
+            {
+                return cachedResult.Value.Value;
+            }
+
+            bool autoGenerated = IsGeneratedDocumentNoCache(tree, cancellationToken);
+
+            // Update the strongbox's value with our computed result.
+            // This doesn't change the strongbox reference, and its presence in the
+            // ConditionalWeakTable is already assured, so we're updating in-place.
+            // In the event of a race condition with another thread that set the value,
+            // we'll just be re-setting it to the same value.
+            cachedResult.Value = autoGenerated;
+
+            return autoGenerated;
+        }
+
+        private static bool IsGeneratedDocumentNoCache(SyntaxTree tree, CancellationToken cancellationToken)
+        {
+            return IsGeneratedFileName(tree.FilePath) || HasAutoGeneratedComment(tree, cancellationToken);
+        }
+
+        /// <summary>
+        /// Checks whether the given document has an auto-generated comment as its header.
+        /// </summary>
+        /// <param name="tree">The syntax tree to examine.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
+        /// <returns>
+        /// <para><see langword="true"/> if <paramref name="tree"/> starts with a comment containing the text
+        /// <c>&lt;auto-generated</c>; otherwise, <see langword="false"/>.</para>
+        /// </returns>
+        private static bool HasAutoGeneratedComment(SyntaxTree tree, CancellationToken cancellationToken)
+        {
+            var root = tree.GetRoot(cancellationToken);
+
+            if (root == null)
+            {
+                return false;
+            }
+
+            var firstToken = root.GetFirstToken();
+            SyntaxTriviaList trivia;
+            if (firstToken == default(SyntaxToken))
+            {
+                var token = ((CompilationUnitSyntax)root).EndOfFileToken;
+                if (!token.HasLeadingTrivia)
+                {
+                    return false;
+                }
+
+                trivia = token.LeadingTrivia;
+            }
+            else
+            {
+                if (!firstToken.HasLeadingTrivia)
+                {
+                    return false;
+                }
+
+                trivia = firstToken.LeadingTrivia;
+            }
+
+            var comments = trivia.Where(t => t.IsKind(SyntaxKind.SingleLineCommentTrivia) || t.IsKind(SyntaxKind.MultiLineCommentTrivia));
+            return comments.Any(t => t.ToString().Contains("<auto-generated"));
+        }
+
+        /// <summary>
+        /// Checks whether the given document has a filename that indicates it is a generated file.
+        /// </summary>
+        /// <param name="filePath">The source file name, without any path.</param>
+        /// <returns>
+        /// <para><see langword="true"/> if <paramref name="filePath"/> is the name of a generated file; otherwise,
+        /// <see langword="false"/>.</para>
+        /// </returns>
+        /// <seealso cref="IsGeneratedDocument(SyntaxTree, CancellationToken)"/>
+        private static bool IsGeneratedFileName(string filePath)
+        {
+            return Regex.IsMatch(
+                Path.GetFileName(filePath),
+                @"(^service|^TemporaryGeneratedFile_.*|^assemblyinfo|^assemblyattributes|\.(g\.i|g|designer|generated|assemblyattributes))\.(cs|vb)$",
+                RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);
+        }
+    }
+}
diff --git a/AsyncUsageAnalyzers/AsyncUsageAnalyzers/Helpers/RenameHelper.cs b/AsyncUsageAnalyzers/AsyncUsageAnalyzers/Helpers/RenameHelper.cs
@@ -0,0 +1,29 @@
+﻿namespace AsyncUsageAnalyzers.Helpers
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CodeActions;
+    using Microsoft.CodeAnalysis.Rename;
+
+    internal static class RenameHelper
+    {
+        public static async Task<Solution> RenameSymbolAsync(Document document, SyntaxNode root, SyntaxToken declarationToken, string newName, CancellationToken cancellationToken)
+        {
+            var annotatedRoot = root.ReplaceToken(declarationToken, declarationToken.WithAdditionalAnnotations(RenameAnnotation.Create()));
+            var annotatedSolution = document.Project.Solution.WithDocumentSyntaxRoot(document.Id, annotatedRoot);
+            var annotatedDocument = annotatedSolution.GetDocument(document.Id);
+
+            annotatedRoot = await annotatedDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var annotatedToken = annotatedRoot.FindToken(declarationToken.SpanStart);
+
+            var semanticModel = await annotatedDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var symbol = semanticModel?.GetDeclaredSymbol(annotatedToken.Parent, cancellationToken);
+
+            var newSolution = await Renamer.RenameSymbolAsync(annotatedSolution, symbol, newName, null, cancellationToken).ConfigureAwait(false);
+
+            // TODO: return annotatedSolution instead of newSolution if newSolution contains any new errors (for any project)
+            return newSolution;
+        }
+    }
+}
diff --git a/AsyncUsageAnalyzers/AsyncUsageAnalyzers/NoCodeFixAttribute.cs b/AsyncUsageAnalyzers/AsyncUsageAnalyzers/NoCodeFixAttribute.cs
@@ -0,0 +1,40 @@
+﻿namespace AsyncUsageAnalyzers
+{
+    using System;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    /// <summary>
+    /// This attribute is applied to <see cref="DiagnosticAnalyzer"/>'s if will not get a code fix.
+    /// Reasons for this would be:
+    /// <list type="bullet">
+    /// <item>Visual Studio provides a built-in code fix.</item>
+    /// <item>A code fix could not provide a useful solution.</item>
+    /// </list>
+    /// The reason should be provided.
+    /// </summary>
+    [AttributeUsage(System.AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
+    public sealed class NoCodeFixAttribute : System.Attribute
+    {
+        private readonly string reason;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NoCodeFixAttribute"/> class.
+        /// </summary>
+        /// <param name="reason">The reason why the <see cref="DiagnosticAnalyzer"/> does not have a code fix.</param>
+        public NoCodeFixAttribute(string reason)
+        {
+            this.reason = reason;
+        }
+
+        /// <summary>
+        /// Gets the reason why the <see cref="DiagnosticAnalyzer"/> does not have a code fix.
+        /// </summary>
+        /// <value>
+        /// The reason why the <see cref="DiagnosticAnalyzer"/> does not have a code fix.
+        /// </value>
+        public string Reason
+        {
+            get { return this.reason; }
+        }
+    }
+}
