Add limitation to the node analysis not only in tests, as originally, but in the actual product code.

Author: kant2002

Nodejs/Product/Analysis/Analysis/AnalysisLimits.cs

@@ -34,7 +34,7 @@ public AnalysisLimits() {
             MaxObjectLiteralProperties = 50;
             MaxObjectKeysTypes = 5;
             MaxMergeTypes = 5;
-            NestedModulesLimit = 4;
+            NestedModulesLimit = AnalysisConstants.MaxAnalysisDepthQualty;
         }
 
         /// <summary>
@@ -43,7 +43,7 @@ public AnalysisLimits() {
         /// <returns>An <see cref="AnalysisLimits"/> object representing medium level Initellisense settings.</returns>
         public static AnalysisLimits MakeMediumAnalysisLimits() {
             return new AnalysisLimits() {
-                NestedModulesLimit = 2
+                NestedModulesLimit = AnalysisConstants.MaxAnalysisDepthFast
             };
         }
 

Nodejs/Product/Analysis/AnalysisConstants.cs

@@ -22,5 +22,40 @@
 namespace Microsoft.NodejsTools {
     internal sealed class AnalysisConstants {
         internal const string NodeModulesFolder = "node_modules";
+
+        /// <summary>
+        /// Maximum practical limit for the dependencies analysis.
+        /// </summary>
+        /// <remarks>
+        /// There no practical reasons to go deeper in dependencies analysis.
+        /// Number 4 is very practical. Here the examples which hightlight idea.
+        /// 
+        /// Example 1
+        /// 
+        /// Level 0 - Large system. Some code should use properties of the object on level 4 here. 
+        /// Level 1 - Subsystem - pass data from level 4
+        /// Level 2 - Internal dependency for company - Do some work and pass data to level 1
+        /// Level 3 - Framework on top of which created Internal dependency.
+        /// Level 4 - Dependency of the framework. Objects from here still should be available.
+        /// Level 5 - Dependency of the framework provide some usefull primitive which would be used very often on the level of whole system. Hmmm.
+        /// 
+        /// Example 2 (reason why I could increase to 5)
+        /// 
+        /// Level 0 - Large system. Some code should use properties of the object on level 4 here. 
+        /// Level 1 - Subsystem - pass data from level 4
+        /// Level 2 - Internal dependency for company - Wrap access to internal library and perform business logic. Do some work and pass data to level 1
+        /// Level 3 - Internal library which wrap access to API.
+        /// Level 4 - Http library.
+        /// Level 5 - Promise Polyfill.
+        ///
+        /// All these examples are highly speculative and I specifically try to create such deep level. 
+        /// If you develop on windows with such deep level you already close to your limit, your maximum is probably 10. 
+        /// </remarks>
+        internal const int MaxAnalysisDepthQualty = 4;
+
+        /// <summary>
+        /// Maximum practical limit for the dependencies analysis oriented on producing faster results.
+        /// </summary>
+        internal const int MaxAnalysisDepthFast = 2;
     }
 }

Nodejs/Product/Nodejs/Project/NodejsProjectNode.cs

@@ -490,6 +490,26 @@ internal bool IncludeNodejsFile(NodejsFileNode fileNode) {
             if (CommonUtils.IsSubpathOf(_intermediateOutputPath, fileNode.Url)) {
                 return false;
             }
+
+            int maxModulesDepth = AnalysisConstants.MaxAnalysisDepthQualty;
+            if (this._analyzer.AnalysisLevel == Options.AnalysisLevel.Medium) {
+                maxModulesDepth = AnalysisConstants.MaxAnalysisDepthFast;
+            }
+
+            var relativeFile = CommonUtils.GetRelativeFilePath(this.FullPathToChildren, fileNode.Url);
+            int nestedModulesCount = 0;
+            int startIndex = 0;
+            int index = relativeFile.IndexOf(AnalysisConstants.NodeModulesFolder, startIndex, StringComparison.OrdinalIgnoreCase);
+            while (index != -1) {
+                nestedModulesCount++;
+                if (nestedModulesCount > maxModulesDepth){
+                    return false;
+                }
+
+                startIndex = index + 1;
+                index = relativeFile.IndexOf(AnalysisConstants.NodeModulesFolder, startIndex, StringComparison.OrdinalIgnoreCase);
+            }
+
             foreach (var path in _analysisIgnoredDirs) {
                 if (url.IndexOf(path, 0, StringComparison.OrdinalIgnoreCase) != -1) {
                     return false;