Various perf fixes to minimize linter CPU impact (#3852)

* Additional perf follow-ups

* Follow up feedback, optimization to reuse semantic models

* Fixes

* Add tracing to CLI

* Add tracing env variable

* Fix lint error

* Add unit test for semantic model deduplication

* Debug -> Trace

* Log trace messages to MSBuild message output

.vscode/launch.json

@@ -2,32 +2,24 @@
     "version": "2.0.0",
     "configurations": [
         {
-            "name": "Bicep VSCode Extension",
+            "name": "VSCode Extension",
             "type": "extensionHost",
             "request": "launch",
             "runtimeExecutable": "${execPath}",
             "args": [
                 "--enable-proposed-api",
                 "--extensionDevelopmentPath=${workspaceRoot}/src/vscode-bicep"
             ],
+            "env": {
+                "BICEP_TRACING_ENABLED": "true"
+            },
             "stopOnEntry": false,
             "sourceMaps": true,
             "outFiles": ["${workspaceRoot}/out/src/**/*.js"],
             "preLaunchTask": "Build VSIX"
         },
         {
-            "name": "Bicep Playground",
-            "type": "node",
-            "request": "launch",
-            "program": "${workspaceFolder}/src/playground/node_modules/webpack/bin/webpack.js",
-            "args": ["serve"],
-            "cwd": "${workspaceFolder}/src/playground",
-            "autoAttachChildProcesses": true,
-            "stopOnEntry": false,
-            "preLaunchTask": "Build WASM for Playground"
-        },
-        {
-            "name": "Bicep CLI",
+            "name": "CLI",
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "Build CLI",
@@ -36,10 +28,24 @@
                 "build",
                 "${file}"
             ],
+            "env": {
+                "BICEP_TRACING_ENABLED": "true"
+            },
             "cwd": "${workspaceFolder}/src/Bicep.Cli",
             "console": "internalConsole",
             "stopAtEntry": false
         },
+        {
+            "name": "Playground",
+            "type": "node",
+            "request": "launch",
+            "program": "${workspaceFolder}/src/playground/node_modules/webpack/bin/webpack.js",
+            "args": ["serve"],
+            "cwd": "${workspaceFolder}/src/playground",
+            "autoAttachChildProcesses": true,
+            "stopOnEntry": false,
+            "preLaunchTask": "Build WASM for Playground"
+        },
         {
             "name": "Textmate Tests",
             "type": "node",

src/Bicep.Cli/Program.cs

@@ -15,6 +15,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Diagnostics;
 using System.Runtime;
 
 namespace Bicep.Cli
@@ -44,7 +45,12 @@ public static int Main(string[] args)
 
         public int Run(string[] args)
         {
-            ServiceProvider serviceProvider = ConfigureServices();
+            var serviceProvider = ConfigureServices();
+
+            if (bool.TryParse(Environment.GetEnvironmentVariable("BICEP_TRACING_ENABLED"), out var enableTracing) && enableTracing)
+            {
+                Trace.Listeners.Add(new TextWriterTraceListener(this.invocationContext.OutputWriter));
+            }
 
             try
             {

src/Bicep.Cli/TextWriterTraceListener.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace Bicep.Cli
+{
+    public class TextWriterTraceListener : TraceListener
+    {
+        private readonly TextWriter textWriter;
+
+        public TextWriterTraceListener(TextWriter textWriter)
+        {
+            this.textWriter = textWriter;
+        }
+
+        public override void Write(string? message)
+        {
+            textWriter.WriteLine($"TRACE: {message}");
+        }
+
+        public override void WriteLine(string? message)
+        {
+            textWriter.WriteLine($"TRACE: {message}");
+        }
+    }
+}

src/Bicep.Core/Analyzers/Linter/Rules/NoHardcodedEnvironmentUrlsRule.cs

@@ -64,14 +64,23 @@ public override IEnumerable<IDiagnostic> AnalyzeInternal(SemanticModel model)
 
         public static IEnumerable<(TextSpan RelativeSpan, string Value)> FindHostnameMatches(string hostname, string srcText)
         {
-            bool isExactDomainMatch(int index)
+            // This code is executed VERY frequently, so we need to be ultra-careful making changes here.
+            // For a compilation, runtime is ~O(number_of_modules * avg_number_of_viable_string_tokens * number_of_hostnames).
+            // In the language service, we recompile on every keypress.
+
+            bool hasLeadingOrTrailingAlphaNumericChar(int index)
             {
-                var leadingAlnum = index > 0 && 
-                    char.IsLetterOrDigit(srcText[index - 1]);
-                var trailingAlnum = index + hostname.Length < srcText.Length && 
-                    char.IsLetterOrDigit(srcText[index + hostname.Length]);
+                if (index > 0 && char.IsLetterOrDigit(srcText[index - 1]))
+                {
+                    return true;
+                }
+
+                if (index + hostname.Length < srcText.Length && char.IsLetterOrDigit(srcText[index + hostname.Length]))
+                {
+                    return true;
+                }
 
-                return !leadingAlnum && !trailingAlnum;
+                return false;
             }
 
             if (hostname.Length == 0)
@@ -91,7 +100,7 @@ bool isExactDomainMatch(int index)
                 }
 
                 // check preceding and trailing chars to verify we're not dealing with a substring
-                if (isExactDomainMatch(matchIndex))
+                if (!hasLeadingOrTrailingAlphaNumericChar(matchIndex))
                 {
                     var matchText = srcText.Substring(matchIndex, hostname.Length);
                     yield return (RelativeSpan: new TextSpan(matchIndex, hostname.Length), Value: matchText);
@@ -170,6 +179,20 @@ public override void VisitStringSyntax(StringSyntax syntax)
                 }
                 base.VisitStringSyntax(syntax);
             }
+
+            public override void VisitResourceDeclarationSyntax(ResourceDeclarationSyntax syntax)
+            {
+                // Skip resource 'type' strings - there's no reason to perform analysis on them
+                this.VisitNodes(syntax.LeadingNodes);
+                this.Visit(syntax.Value);
+            }
+
+            public override void VisitModuleDeclarationSyntax(ModuleDeclarationSyntax syntax)
+            {
+                // Skip resource 'path' strings - there's no reason to perform analysis on them
+                this.VisitNodes(syntax.LeadingNodes);
+                this.Visit(syntax.Value);
+            }
         }
     }
 }

src/Bicep.Core/Extensions/EnumerableExtensions.cs

@@ -74,6 +74,14 @@ public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TS
                 }
             }
         }
+
+        public static ILookup<T, T> InvertLookup<T>(this ILookup<T, T> source)
+            => source.SelectMany(group => group.Select(val => (group.Key, val)))
+                .ToLookup(x => x.val, x => x.Key);
+
+        public static ImmutableDictionary<TKey, ImmutableHashSet<TValue>> ToImmutableDictionary<TKey, TValue>(this ILookup<TKey, TValue> source)
+            where TKey : notnull
+            => source.ToImmutableDictionary(x => x.Key, x => x.ToImmutableHashSet());
     }
 }
 

src/Bicep.Core/Semantics/ArmTemplateSemanticModel.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using Azure.Deployments.Core.Definitions.Schema;
 using Azure.Deployments.Core.Entities;
@@ -24,6 +25,8 @@ public class ArmTemplateSemanticModel : ISemanticModel
 
         public ArmTemplateSemanticModel(ArmTemplateFile sourceFile)
         {
+            Trace.WriteLine($"Building semantic model for {sourceFile.FileUri}");
+
             this.SourceFile = sourceFile;
 
             this.targetScopeLazy = new(() =>

src/Bicep.Core/Semantics/Compilation.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using Bicep.Core.Configuration;
 using Bicep.Core.Diagnostics;
+using Bicep.Core.Extensions;
 using Bicep.Core.TypeSystem;
 using Bicep.Core.Workspaces;
 
@@ -15,18 +16,20 @@ public class Compilation
     {
         private readonly ImmutableDictionary<ISourceFile, Lazy<ISemanticModel>> lazySemanticModelLookup;
 
-        public Compilation(IResourceTypeProvider resourceTypeProvider, SourceFileGrouping sourceFileGrouping)
+        public Compilation(IResourceTypeProvider resourceTypeProvider, SourceFileGrouping sourceFileGrouping, ImmutableDictionary<ISourceFile, ISemanticModel>? modelLookup = null)
         {
             this.SourceFileGrouping = sourceFileGrouping;
             this.ResourceTypeProvider = resourceTypeProvider;
             this.lazySemanticModelLookup = sourceFileGrouping.SourceFiles.ToImmutableDictionary(
                 sourceFile => sourceFile,
-                sourceFile => new Lazy<ISemanticModel>(() => sourceFile switch
-                {
-                    BicepFile bicepFile => new SemanticModel(this, bicepFile, SourceFileGrouping.FileResolver),
-                    ArmTemplateFile armTemplateFile => new ArmTemplateSemanticModel(armTemplateFile),
-                    _ => throw new ArgumentOutOfRangeException(nameof(sourceFile)),
-                }));
+                sourceFile => (modelLookup is not null && modelLookup.TryGetValue(sourceFile, out var existingModel)) ? 
+                    new(existingModel) : 
+                    new Lazy<ISemanticModel>(() => sourceFile switch
+                    {
+                        BicepFile bicepFile => new SemanticModel(this, bicepFile, SourceFileGrouping.FileResolver),
+                        ArmTemplateFile armTemplateFile => new ArmTemplateSemanticModel(armTemplateFile),
+                        _ => throw new ArgumentOutOfRangeException(nameof(sourceFile)),
+                    }));
         }
 
         public SourceFileGrouping SourceFileGrouping { get; }

src/Bicep.Core/Semantics/SemanticModel.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
 using Bicep.Core.Analyzers.Linter;
 using Bicep.Core.Configuration;
@@ -32,6 +33,8 @@ public class SemanticModel : ISemanticModel
 
         public SemanticModel(Compilation compilation, BicepFile sourceFile, IFileResolver fileResolver)
         {
+            Trace.WriteLine($"Building semantic model for {sourceFile.FileUri}");
+
             Compilation = compilation;
             SourceFile = sourceFile;
             FileResolver = fileResolver;

src/Bicep.Core/Workspaces/SourceFileGrouping.cs

@@ -1,10 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using Bicep.Core.Diagnostics;
 using Bicep.Core.FileSystem;
 using Bicep.Core.Syntax;
+using System.Linq;
 using static Bicep.Core.Diagnostics.DiagnosticBuilder;
 
 namespace Bicep.Core.Workspaces
@@ -16,19 +18,23 @@ public SourceFileGrouping(
             BicepFile entryPoint,
             ImmutableHashSet<ISourceFile> sourceFiles,
             ImmutableDictionary<ModuleDeclarationSyntax, ISourceFile> sourceFilesByModuleDeclaration,
+            ImmutableDictionary<ISourceFile, ImmutableHashSet<ISourceFile>> sourceFileParentLookup,
             ImmutableDictionary<ModuleDeclarationSyntax, ErrorBuilderDelegate> errorBuildersByModuleDeclaration,
             ImmutableHashSet<ModuleDeclarationSyntax> modulesToRestore)
         {
             this.FileResolver = fileResolver;
             this.EntryPoint = entryPoint;
             this.SourceFiles = sourceFiles;
             this.SourceFilesByModuleDeclaration = sourceFilesByModuleDeclaration;
+            this.SourceFileParentLookup = sourceFileParentLookup;
             this.ErrorBuildersByModuleDeclaration = errorBuildersByModuleDeclaration;
             this.ModulesToRestore = modulesToRestore;
         }
 
         public ImmutableDictionary<ModuleDeclarationSyntax, ISourceFile> SourceFilesByModuleDeclaration { get; }
 
+        public ImmutableDictionary<ISourceFile, ImmutableHashSet<ISourceFile>> SourceFileParentLookup { get; }
+
         public ImmutableDictionary<ModuleDeclarationSyntax, ErrorBuilderDelegate> ErrorBuildersByModuleDeclaration { get; }
 
         public ImmutableHashSet<ModuleDeclarationSyntax> ModulesToRestore { get; }
@@ -42,6 +48,28 @@ public SourceFileGrouping(
         public ISourceFile LookUpModuleSourceFile(ModuleDeclarationSyntax moduleDeclaration) =>
             this.SourceFilesByModuleDeclaration[moduleDeclaration];
 
+        public ImmutableHashSet<ISourceFile> GetFilesDependingOn(ISourceFile sourceFile)
+        {
+            var filesToCheck = new Queue<ISourceFile>(new [] { sourceFile });
+            var knownFiles = new HashSet<ISourceFile>();
+
+            while (filesToCheck.TryDequeue(out var current))
+            {
+                knownFiles.Add(current);
+
+                if (SourceFileParentLookup.TryGetValue(current, out var parents))
+                {
+                    foreach (var parent in parents.Where(x => !knownFiles.Contains(x)))
+                    {
+                        knownFiles.Add(parent);
+                        filesToCheck.Enqueue(parent);
+                    }
+                }
+            }
+
+            return knownFiles.ToImmutableHashSet();
+        }
+
         public bool TryLookUpModuleErrorDiagnostic(ModuleDeclarationSyntax moduleDeclaration, [NotNullWhen(true)] out ErrorDiagnostic? errorDiagnostic)
         {
             if (this.ErrorBuildersByModuleDeclaration.TryGetValue(moduleDeclaration, out var errorBuilder))

src/Bicep.Core/Workspaces/SourceFileGroupingBuilder.cs

@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.Linq;
 using Bicep.Core.Diagnostics;
+using Bicep.Core.Extensions;
 using Bicep.Core.FileSystem;
 using Bicep.Core.Parsing;
 using Bicep.Core.Registry;
@@ -97,13 +98,14 @@ private SourceFileGrouping Build(Uri entryFileUri)
                 throw new InvalidOperationException($"Expected {nameof(PopulateRecursive)} to return a BicepFile.");
             }
 
-            this.ReportFailuresForCycles();
+            var sourceFileDependencies = this.ReportFailuresForCycles();
 
             return new SourceFileGrouping(
                 fileResolver,
                 entryPoint,
                 sourceFilesByUri.Values.ToImmutableHashSet(),
                 sourceFilesByModuleDeclaration.ToImmutableDictionary(),
+                sourceFileDependencies.InvertLookup().ToImmutableDictionary(),
                 errorBuildersByModuleDeclaration.ToImmutableDictionary(),
                 modulesToInit.ToImmutableHashSet());
         }
@@ -215,7 +217,7 @@ private ISourceFile AddSourceFile(Uri fileUri, string fileContents, bool isEntry
             return sourceFile;
         }
 
-        private void ReportFailuresForCycles()
+        private ILookup<ISourceFile, ISourceFile> ReportFailuresForCycles()
         {
             var sourceFileGraph = this.sourceFilesByUri.Values
                 .SelectMany(sourceFile => GetModuleDeclarations(sourceFile)
@@ -226,20 +228,22 @@ private void ReportFailuresForCycles()
                 .ToLookup(x => x.sourceFile, x => x.referencedFile);
 
             var cycles = CycleDetector<ISourceFile>.FindCycles(sourceFileGraph);
-            foreach (var kvp in sourceFilesByModuleDeclaration)
+            foreach (var (moduleDeclaration, moduleSourceFile) in sourceFilesByModuleDeclaration)
             {
-                if (cycles.TryGetValue(kvp.Value, out var cycle))
+                if (cycles.TryGetValue(moduleSourceFile, out var cycle))
                 {
                     if (cycle.Length == 1)
                     {
-                        errorBuildersByModuleDeclaration[kvp.Key] = x => x.CyclicModuleSelfReference();
+                        errorBuildersByModuleDeclaration[moduleDeclaration] = x => x.CyclicModuleSelfReference();
                     }
                     else
                     {
-                        errorBuildersByModuleDeclaration[kvp.Key] = x => x.CyclicModule(cycle.Select(x => x.FileUri.LocalPath));
+                        errorBuildersByModuleDeclaration[moduleDeclaration] = x => x.CyclicModule(cycle.Select(x => x.FileUri.LocalPath));
                     }
                 }
             }
+
+            return sourceFileGraph;
         }
 
         private static IEnumerable<ModuleDeclarationSyntax> GetModuleDeclarations(ISourceFile sourceFile) => sourceFile is BicepFile bicepFile

src/Bicep.LangServer.UnitTests/BicepCompilationManagerHelper.cs

@@ -30,7 +30,7 @@ public static BicepCompilationManager CreateCompilationManager(DocumentUri docum
 
             var document = CreateMockDocument(p => receivedParams = p);
             var server = CreateMockServer(document);
-            BicepCompilationManager bicepCompilationManager = new BicepCompilationManager(server.Object, CreateEmptyCompilationProvider(), new Workspace(), BicepCompilationManagerHelper.CreateMockScheduler().Object);
+            BicepCompilationManager bicepCompilationManager = new BicepCompilationManager(server.Object, CreateEmptyCompilationProvider(), new Workspace(), new FileResolver(), BicepCompilationManagerHelper.CreateMockScheduler().Object);
 
             if (upsertCompilation)
             {