Fixing test failure because of extra call

CTrando · CTrando · commit 82a03de57ee8 · 2019-07-03T18:39:10.000-07:00
diff --git a/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.Callables.cs b/src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.Callables.cs
@@ -180,7 +180,6 @@ public IMember GetValueFromFunctionType(IPythonFunctionType fn, IPythonInstance
 
                 LoadFunctionDependencyModules(fn);
 
-                var tmp = instance?.Call(fn.Name, args);
                 var t = instance?.Call(fn.Name, args) ?? fn.Call(null, fn.Name, args);
                 if (!t.IsUnknown()) {
                     return t;
diff --git a/src/Analysis/Ast/Impl/Analyzer/Handlers/WithHandler.cs b/src/Analysis/Ast/Impl/Analyzer/Handlers/WithHandler.cs
@@ -35,7 +35,7 @@ public void HandleWith(WithStatement node) {
                     // If fetching context from __enter__ failed, annotation in the stub may be using
                     // type from typing that we haven't specialized yet or there may be an issue in
                     // the stub itself, such as type or incorrect type. Try using context manager then.
-                    context = context.IsUnknown() ? contextManager: context;
+                    context = context ?? contextManager;
                 }
 
                 if (item.Variable is NameExpression nex && !string.IsNullOrEmpty(nex.Name)) {
diff --git a/src/Analysis/Ast/Impl/Extensions/AnalysisExtensions.cs b/src/Analysis/Ast/Impl/Extensions/AnalysisExtensions.cs
@@ -44,7 +44,9 @@ internal static void SpecializeFunction(this IDocumentAnalysis analysis, string
             var f = analysis.GetOrCreateFunction(name);
             if (f != null) {
                 foreach (var o in f.Overloads.OfType<PythonFunctionOverload>()) {
-                    o.SetParameters(parameters);
+                    if(parameters.Count > 0) {
+                        o.SetParameters(parameters);
+                    }
                     o.SetReturnValueProvider(returnTypeCallback);
                 }
                 f.Specialize(dependencies);
diff --git a/src/Analysis/Ast/Impl/Types/ArgumentSet.cs b/src/Analysis/Ast/Impl/Types/ArgumentSet.cs
@@ -116,7 +116,7 @@ public ArgumentSet(IPythonFunctionType fn, int overloadIndex, IPythonInstance in
             // Some specialized functions have more complicated definitions, so we pass
             // parameters to those, TypeVar() is an example, so we allow the latter logic to handle
             // argument instatiation. For simple specialized functions, it is enough to handle here.
-            if (fn.IsSpecialized) {
+            if (fn.IsSpecialized && overload.Parameters.Count == 0) {
                 // Specialized functions typically don't have AST definitions.
                 // We construct the arguments from the call expression. If an argument does not have a name, 
                 // we try using name from the function definition based on the argument's position.

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public void HandleWith(WithStatement node) {`
`35`	`35`	`// If fetching context from __enter__ failed, annotation in the stub may be using`
`36`	`36`	`// type from typing that we haven't specialized yet or there may be an issue in`
`37`	`37`	`// the stub itself, such as type or incorrect type. Try using context manager then.`
`38`		`- context = context.IsUnknown() ? contextManager: context;`
	`38`	`+ context = context ?? contextManager;`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`if (item.Variable is NameExpression nex && !string.IsNullOrEmpty(nex.Name)) {`