Move RequireAnalysisUnit instantiation to TreeUpdateAnalysis so that it is

called on the analysis thread.

Author: mousetraps

Nodejs/Product/Analysis/Analysis/AnalysisLog.cs

@@ -87,19 +87,17 @@ private void Add(string Event, params object[] Args) {
             int max = MaxItems;
 
             if (max != 0) {
-                lock (LogItems) {
-                    if (LogItems.Count >= max) {
-                        while (LogItems.Count > max) {
-                            // if the queue was set to shrink remove any old items.
-                            LogItems.PopLeft();
-                        }
-                        if (LogIndex >= max) {
-                            LogIndex = 0;
-                        }
-                        LogItems[LogIndex++] = new LogItem { Time = Time, Event = Event, Args = Args };
-                    } else {
-                        LogItems.Append(new LogItem { Time = Time, Event = Event, Args = Args });
+                if (LogItems.Count >= max) {
+                    while (LogItems.Count > max) {
+                        // if the queue was set to shrink remove any old items.
+                        LogItems.PopLeft();
                     }
+                    if (LogIndex >= max) {
+                        LogIndex = 0;
+                    }
+                    LogItems[LogIndex++] = new LogItem { Time = Time, Event = Event, Args = Args };
+                } else {
+                    LogItems.Append(new LogItem { Time = Time, Event = Event, Args = Args });
                 }
             }
         }

Nodejs/Product/Analysis/Analysis/Analyzer/AnalysisUnit.cs

@@ -32,6 +32,9 @@ namespace Microsoft.NodejsTools.Analysis {
     /// Our dependency tracking scheme works by tracking analysis units - when we add a dependency it is the current
     /// AnalysisUnit which is dependent upon the variable.  If the value of a variable changes then all of the dependent
     /// AnalysisUnit's will be re-enqueued.  This proceeds until we reach a fixed point.
+    /// 
+    /// Note that AnalysisUnit contructors / methods are not threadsafe because we expect there to be many AnalysisUnits,
+    /// and we want to keep things as performant as possible (which means minimizing locking behavior and whatnot.)
     /// </summary>
     [Serializable]
     internal class AnalysisUnit : ISet<AnalysisUnit> {

Nodejs/Product/Analysis/Analysis/JsAnalyzer.cs

@@ -143,15 +143,12 @@ public IAnalyzable AddPackageJson(string filePath, string entryPoint, List<strin
 
             tree.DefaultPackage = entryPoint;
 
-            var requireAnalysisUnits = new List<RequireAnalysisUnit>();
+            ProjectEntry projectEntry = null;
             if (dependencies != null) {
-                var projectEntry = new ProjectEntry(this, filePath, null);
-                requireAnalysisUnits.AddRange(dependencies.Select(
-                    dependency => { return new RequireAnalysisUnit(tree, Modules, projectEntry, dependency);
-                }));
+                projectEntry = new ProjectEntry(this, filePath, null);
             }
 
-            return new TreeUpdateAnalysis(tree, requireAnalysisUnits);
+            return new TreeUpdateAnalysis(tree, dependencies, projectEntry, Modules);
         }
 
         /// <summary>
@@ -162,22 +159,33 @@ public IAnalyzable AddPackageJson(string filePath, string entryPoint, List<strin
         [Serializable]
         internal class TreeUpdateAnalysis : IAnalyzable {
             private readonly ModuleTree _tree;
-            private readonly IEnumerable<RequireAnalysisUnit> _requireAnalysisUnits;
+            private readonly IEnumerable<string> _dependencies;
+            private readonly ProjectEntry _projectEntry;
+            private readonly ModuleTable _modules;
 
-            public TreeUpdateAnalysis(ModuleTree tree, IEnumerable<RequireAnalysisUnit> requireAnalysisUnits = null) {
+            public TreeUpdateAnalysis(ModuleTree tree, IEnumerable<string> dependencies = null, ProjectEntry projectEntry = null, ModuleTable modules = null) {
                 _tree = tree;
-                _requireAnalysisUnits = requireAnalysisUnits;
+                _dependencies = dependencies;
+                _projectEntry = projectEntry;
+                _modules = modules;
             }
 
             public void Analyze(CancellationToken cancel) {
                 if (_tree != null) {
                     _tree.EnqueueDependents();
                 }
-                if (_requireAnalysisUnits != null) {
-                    foreach (var unit in _requireAnalysisUnits) {
+                
+                if (_dependencies != null) {
+                    var requireAnalysisUnits = new List<RequireAnalysisUnit>();
+                    requireAnalysisUnits.AddRange(_dependencies.Select(
+                        dependency => {
+                            return new RequireAnalysisUnit(_tree, _modules, _projectEntry, dependency);
+                        }));
+
+                    foreach (var unit in requireAnalysisUnits) {
                         unit.AnalyzeWorker(null, cancel);
                     }
-                }
+                }
             }
         }