Merge pull request microsoft#146 from kant2002/high_mem

Fix microsoft#138 Add medium level of IntelliSense / limit to the analysis depth (Related to microsoft#88).

Limit depth analysys to relative paths which contains only 2 node_modules. This should be sufficient enough to capture
a) Capture API of the root package
b) Capture API of the dependencies. This is obiviously the must to analyze (1 node_modules)
c) Capture API of subdependencies (2 node_modules). This is also the must, since a lot of packages are wrapper/glue for another library. For example using gulp-typescript require that gulp-typescript should be parsed (level b) and typescript should be parsed (level c) since typescritp provide some config options for gulp-typescript.

Related to microsoft#88 

microsoft#138 Added Medium level of Intellisense. This level now same as Full level, but limit analysis depth to the 2 nested modules depth. Full mode is now has limit to 4 modules depth which I almost sure practical enough, but could be increased if needed. Low level is analyse 1 level depth.

Author: mousetraps

Nodejs/Product/Analysis/Analysis/AnalysisLimits.cs

@@ -34,6 +34,43 @@ public AnalysisLimits() {
             MaxObjectLiteralProperties = 50;
             MaxObjectKeysTypes = 5;
             MaxMergeTypes = 5;
+
+            // 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. 
+            NestedModulesLimit = 4;
+        }
+
+        /// <summary>
+        /// Creates instance of the <see cref="AnalysisLimits"/> for medium level of Intellisense support.
+        /// </summary>
+        /// <returns>An <see cref="AnalysisLimits"/> object representing medium level Initellisense settings.</returns>
+        public static AnalysisLimits MakeMediumAnalysisLimits() {
+            return new AnalysisLimits() {
+
+                // Maximum practical limit for the dependencies analysis oriented on producing faster results.
+                NestedModulesLimit = 2
+            };
         }
 
         public static AnalysisLimits MakeLowAnalysisLimits() {
@@ -43,7 +80,8 @@ public static AnalysisLimits MakeLowAnalysisLimits() {
                 DictKeyTypes = 1,
                 DictValueTypes = 1,
                 IndexTypes = 1,
-                InstanceMembers = 1
+                InstanceMembers = 1,
+                NestedModulesLimit = 1
             };
         }
 
@@ -111,6 +149,33 @@ public static AnalysisLimits MakeLowAnalysisLimits() {
         /// </summary>
         public int MaxMergeTypes { get; set; }
 
+        /// <summary>
+        /// Gets the maximum level of dependency modules which could be analyzed.
+        /// </summary>
+        public int NestedModulesLimit { get; set; }
+
+        /// <summary>
+        /// Checks whether relative path exceed the nested module limit.
+        /// </summary>
+        /// <param name="path">Path to module file which has to be checked for depth limit.</param>
+        /// <returns>True if path too deep in nesting tree; false overwise.</returns>
+        public bool IsPathExceedNestingLimit(string path) { 
+            int nestedModulesCount = 0;
+            int startIndex = 0;
+            int index = path.IndexOf(AnalysisConstants.NodeModulesFolder, startIndex, StringComparison.OrdinalIgnoreCase);
+            while (index != -1) {
+                nestedModulesCount++;
+                if (nestedModulesCount > this.NestedModulesLimit){
+                    return true;
+                }
+
+                startIndex = index + AnalysisConstants.NodeModulesFolder.Length;
+                index = path.IndexOf(AnalysisConstants.NodeModulesFolder, startIndex, StringComparison.OrdinalIgnoreCase);
+            }
+
+            return false;
+        }
+
         public override bool Equals(object obj) {
             AnalysisLimits other = obj as AnalysisLimits;
             if (other != null) {
@@ -125,7 +190,8 @@ public override bool Equals(object obj) {
                     other.MaxArrayLiterals == MaxArrayLiterals &&
                     other.MaxObjectLiteralProperties == MaxObjectLiteralProperties &&
                     other.MaxObjectKeysTypes == MaxObjectKeysTypes &&
-                    other.MaxMergeTypes == MaxMergeTypes;
+                    other.MaxMergeTypes == MaxMergeTypes &&
+                    other.NestedModulesLimit == NestedModulesLimit;
             }
             return false;
         }
@@ -142,7 +208,8 @@ public override int GetHashCode() {
                 MaxArrayLiterals +
                 MaxObjectLiteralProperties +
                 MaxObjectKeysTypes +
-                MaxMergeTypes;
+                MaxMergeTypes +
+                NestedModulesLimit;
         }
     }
 }

Nodejs/Product/Nodejs/Intellisense/VsProjectAnalyzer.cs

@@ -1459,6 +1459,9 @@ private AnalysisLimits LoadLimits() {
 
             if (NodejsPackage.Instance != null) {
                 switch (_analysisLevel) {
+                    case Options.AnalysisLevel.Medium:
+                        defaults = AnalysisLimits.MakeMediumAnalysisLimits();
+                        break;
                     case Options.AnalysisLevel.Low:
                         defaults = _lowLimits;
                         break;
@@ -1500,6 +1503,7 @@ private static AnalysisLimits LoadLimitsFromStorage(RegistryKey key, AnalysisLim
             limits.DictValueTypes = GetSetting(key, DictValueTypesId) ?? defaults.DictValueTypes;
             limits.IndexTypes = GetSetting(key, IndexTypesId) ?? defaults.IndexTypes;
             limits.AssignedTypes = GetSetting(key, AssignedTypesId) ?? defaults.AssignedTypes;
+            limits.NestedModulesLimit = GetSetting(key, NestedModulesLimitId) ?? defaults.NestedModulesLimit;
 
             return limits;
         }
@@ -1518,6 +1522,7 @@ private static AnalysisLimits LoadLimitsFromStorage(RegistryKey key, AnalysisLim
         private const string DictValueTypesId = "DictValueTypes";
         private const string IndexTypesId = "IndexTypes";
         private const string AssignedTypesId = "AssignedTypes";
+        private const string NestedModulesLimitId = "NestedModulesLimit";
 
         #endregion
     }

Nodejs/Product/Nodejs/Options/AnalysisLevel.cs

@@ -18,6 +18,7 @@ namespace Microsoft.NodejsTools.Options {
     enum AnalysisLevel {
         None,
         Low,
+        Medium,
         High
     }
 }

Nodejs/Product/Nodejs/Options/NodejsIntellisenseOptionsControl.Designer.cs

@@ -42,6 +42,8 @@ internal AnalysisLevel AnalysisLevel {
             get {
                 if (_fullIntelliSenseRadioButton.Checked) {
                     return AnalysisLevel.High;
+                } else if (_mediumIntelliSenseRadioButton.Checked) {
+                    return AnalysisLevel.Medium;
                 } else {
                     return AnalysisLevel.None;
                 }
@@ -51,6 +53,9 @@ internal AnalysisLevel AnalysisLevel {
                     case AnalysisLevel.High:
                         _fullIntelliSenseRadioButton.Checked = true;
                         break;
+                    case AnalysisLevel.Medium:
+                        _mediumIntelliSenseRadioButton.Checked = true;
+                        break;
                     case AnalysisLevel.None:
                         _noIntelliSenseRadioButton.Checked = true;
                         break;