Added some performance optimizations to handle cases where there are …

…many overloads for a function (>100). Previous code hit n^2 analysis times where n is number of overloads.
microsoft · Feb 3, 2021 · d9f621e · d9f621e
1 parent 77410d8
commit d9f621e
Show file tree

Hide file tree

Showing 2 changed files with 22 additions and 5 deletions.
diff --git a/packages/pyright-internal/src/analyzer/checker.ts b/packages/pyright-internal/src/analyzer/checker.ts
@@ -418,11 +418,18 @@ export class Checker extends ParseTreeWalker {
         if (functionTypeResult && isOverloadedFunction(functionTypeResult.decoratedType)) {
             const overloads = functionTypeResult.decoratedType.overloads;
             if (overloads.length > 1) {
-                this._validateOverloadConsistency(
-                    node,
-                    overloads[overloads.length - 1],
-                    overloads.slice(0, overloads.length - 1)
-                );
+                const maxOverloadConsistencyCheckLength = 100;
+
+                // The check is n^2 in time, so if the number of overloads
+                // is very large (which can happen for some generated code),
+                // skip this check to avoid quadratic analysis time.
+                if (overloads.length < maxOverloadConsistencyCheckLength) {
+                    this._validateOverloadConsistency(
+                        node,
+                        overloads[overloads.length - 1],
+                        overloads.slice(0, overloads.length - 1)
+                    );
+                }
             }
         }
 

diff --git a/packages/pyright-internal/src/analyzer/typeEvaluator.ts b/packages/pyright-internal/src/analyzer/typeEvaluator.ts
@@ -12144,6 +12144,16 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
             // Find this function's declaration.
             const declIndex = decls.findIndex((decl) => decl === functionDecl);
             if (declIndex > 0) {
+                // Evaluate all of the previous function declarations. They will
+                // be cached. We do it in this order to avoid a stack overflow due
+                // to recursion if there is a large number (1000's) of overloads.
+                for (let i = 0; i < declIndex; i++) {
+                    const decl = decls[i];
+                    if (decl.type === DeclarationType.Function) {
+                        getTypeOfFunction(decl.node);
+                    }
+                }
+
                 const overloadedTypes: FunctionType[] = [];
 
                 // Look at the previous declaration's type.