Overload tests

Author: MikhailArkhipov

src/Analysis/Engine/Impl/OverloadResult.cs

@@ -16,6 +16,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -26,26 +27,25 @@
 namespace Microsoft.PythonTools.Analysis {
     public class OverloadResult : IOverloadResult {
         private readonly ParameterResult[] _parameters;
-        private readonly IAnalysisSet _returnTypes;
+        private readonly string[] _returnType;
 
-        public OverloadResult(ParameterResult[] parameters, string name, string documentation, IAnalysisSet returnTypes) {
+        public OverloadResult(ParameterResult[] parameters, string name, string documentation, IEnumerable<string> returnType) {
             _parameters = parameters;
             Name = name;
             Documentation = documentation;
-            _returnTypes = returnTypes;
+            _returnType = returnType.MaybeEnumerate().ToArray();
         }
 
         public string Name { get; }
-        public virtual IReadOnlyList<string> ReturnType => _returnTypes.Select(t => t.Name).ToArray();
-        public virtual IAnalysisSet ReturnTypes => _returnTypes;
+        public virtual IReadOnlyList<string> ReturnType => _returnType;
         public virtual string Documentation { get; }
         public virtual ParameterResult[] Parameters => _parameters;
 
         internal virtual OverloadResult WithNewParameters(ParameterResult[] newParameters)
-            => new OverloadResult(newParameters, Name, Documentation, ReturnTypes);
+            => new OverloadResult(newParameters, Name, Documentation, _returnType);
 
         internal virtual OverloadResult WithoutLeadingParameters(int skipCount = 1)
-            => new OverloadResult(_parameters.Skip(skipCount).ToArray(), Name, Documentation, _returnTypes);
+            => new OverloadResult(_parameters.Skip(skipCount).ToArray(), Name, Documentation, _returnType);
 
         private static string Longest(string x, string y) {
             if (x == null) {
@@ -115,8 +115,8 @@ public static OverloadResult Merge(IEnumerable<OverloadResult> overloads) {
                 return res;
             });
 
-            var returnTypes = overloads.SelectMany(o => o.ReturnTypes).Distinct();
-            return new OverloadResult(parameters, name, doc, AnalysisSet.Create(returnTypes));
+            var returnType = overloads.SelectMany(o => o.ReturnType).Distinct();
+            return new OverloadResult(parameters, name, doc, returnType);
         }
 
         public override string ToString() {
@@ -131,7 +131,7 @@ public override string ToString() {
 
             var returnType = "{0}{1}{2}".FormatInvariant(
                 ReturnType.Count > 1 ? "[" : string.Empty,
-                ReturnType.Count > 0 ? string.Join(",", ReturnType.OrderBy(k => k)) : "None",
+                ReturnType.Count > 0 ? string.Join(", ", ReturnType.OrderBy(k => k)) : "None",
                 ReturnType.Count > 1 ? "]" : string.Empty
             );
 
@@ -146,7 +146,7 @@ class AccumulatedOverloadResult {
         private string[] _pnames;
         private IAnalysisSet[] _ptypes;
         private string[] _pdefaults;
-        private IAnalysisSet _rtypes;
+        private readonly HashSet<string> _rtypes;
 
         public AccumulatedOverloadResult(string name, string documentation, int parameters) {
             _name = name;
@@ -155,7 +155,7 @@ public AccumulatedOverloadResult(string name, string documentation, int paramete
             _ptypes = new IAnalysisSet[parameters];
             _pdefaults = new string[parameters];
             ParameterCount = parameters;
-            _rtypes = AnalysisSet.Empty;
+            _rtypes = new HashSet<string>();
         }
 
         public int ParameterCount { get; }
@@ -184,12 +184,12 @@ private IAnalysisSet ChooseBest(IAnalysisSet x, IAnalysisSet y) {
                 return (y == null) ? AnalysisSet.Empty : y;
             }
             if (y == null || y.IsObjectOrUnknown()) {
-                return null;
+                return AnalysisSet.Empty;
             }
-            return MergeTypes(x, y);
+            return x.Union(y);
         }
 
-        public bool TryAddOverload(string name, string documentation, string[] names, IAnalysisSet[] types, string[] defaults, IAnalysisSet returnTypes) {
+        public bool TryAddOverload(string name, string documentation, string[] names, IAnalysisSet[] types, string[] defaults, IEnumerable<string> returnTypes) {
             if (names.Length != _pnames.Length || types.Length != _ptypes.Length) {
                 return false;
             }
@@ -203,7 +203,7 @@ public bool TryAddOverload(string name, string documentation, string[] names, IA
                 return false;
             }
 
-            for (int i = 0; i < _pnames.Length; ++i) {
+            for (var i = 0; i < _pnames.Length; ++i) {
                 _pnames[i] = ChooseBest(_pnames[i], names[i]);
                 _ptypes[i] = ChooseBest(_ptypes[i], types[i]);
                 _pdefaults[i] = ChooseBest(_pdefaults[i], defaults[i]);
@@ -217,7 +217,7 @@ public bool TryAddOverload(string name, string documentation, string[] names, IA
             }
 
             if (returnTypes != null) {
-                _rtypes = ChooseBest(_rtypes, returnTypes);
+                _rtypes.UnionWith(returnTypes);
             }
 
             return true;
@@ -241,27 +241,6 @@ public OverloadResult ToOverloadResult() {
             }
             return new OverloadResult(parameters, _name, _doc, _rtypes);
         }
-
-        private IAnalysisSet MergeTypes(IAnalysisSet x, IAnalysisSet y) {
-            // Merge types so we get simple parameter description such as 
-            // list[int] rather than duplicates such as  list[int],list[int, int, int].
-            var cmp = UnionComparer.Instances[1];
-            var xA = x.ToArray();
-            var yA = y.ToArray();
-            var mergedValues = new List<AnalysisValue>();
-            for (var i = 0; i < xA.Length; i++) {
-                // Order types for merging in the order of description length
-                // so more complex type would possibly fold into the simpler type
-                // such as list[int, int, int] will fold into the list[int].
-                
-                // TODO: this is not bulletproof. 
-                // For example, it will merge user type derived from int into the int.
-                var xd = string.Join(",", xA[i].GetShortDescriptions());
-                var yd = string.Join(",", yA[i].GetShortDescriptions());
-                mergedValues.Add(xd.Length < yd.Length ? cmp.MergeTypes(xA[i], yA[i], out _) : cmp.MergeTypes(yA[i], xA[i], out _));
-            }
-            return AnalysisSet.CreateUnion(mergedValues, cmp);
-        }
     }
 
     class BuiltinFunctionOverloadResult : OverloadResult {

src/Analysis/Engine/Impl/Values/BuiltinInstanceInfo.cs

@@ -33,6 +33,7 @@ public BuiltinInstanceInfo(BuiltinClassInfo klass)
         IBuiltinClassInfo IBuiltinInstanceInfo.ClassInfo => ClassInfo;
         public BuiltinClassInfo ClassInfo => _klass;
 
+        public override string Name => _klass.Name;
         public override IPythonType PythonType => _type;
 
         public override IAnalysisSet GetInstanceType() {
@@ -165,7 +166,7 @@ public override IAnalysisSet Call(Node node, AnalysisUnit unit, IAnalysisSet[] a
                     Pop();
                 }
             }
-            
+
             return res;
         }
 
@@ -330,18 +331,18 @@ internal override AnalysisValue UnionMergeTypes(AnalysisValue ns, int strength)
                 return ProjectState.ClassInfos[BuiltinTypeId.Object].Instance;
 
             } else if (strength >= MergeStrength.ToBaseClass) {
-                var bii = ns as BuiltinInstanceInfo;
-                if (bii != null) {
+                if (ns is BuiltinInstanceInfo bii) {
                     return ClassInfo.UnionMergeTypes(bii.ClassInfo, strength).GetInstanceType().Single();
                 }
-                var ii = ns as InstanceInfo;
-                if (ii != null) {
+                if (ns is InstanceInfo ii) {
                     return ClassInfo.UnionMergeTypes(ii.ClassInfo, strength).GetInstanceType().Single();
                 }
+                if (ns is ProtocolInfo pi) {
+                    return pi.UnionMergeTypes(this, strength).GetInstanceType().Single();
+                }
             } else if (this is ConstantInfo || ns is ConstantInfo) {
                 return ClassInfo.Instance;
             }
-
             return base.UnionMergeTypes(ns, strength);
         }
 

src/Analysis/Engine/Impl/Values/ClassInfo.cs

@@ -271,7 +271,7 @@ public override IEnumerable<OverloadResult> Overloads {
                                                 overload.Parameters,
                                                 ClassDefinition.Name,
                                                 overload.Documentation,
-                                                overload.ReturnTypes
+                                                overload.ReturnType
                                             )
                                         );
                                     }
@@ -289,7 +289,7 @@ public override IEnumerable<OverloadResult> Overloads {
                         new ParameterResult[0],
                         ClassDefinition.Name,
                         ClassDefinition.Body.Documentation.TrimDocumentation(),
-                        AnalysisSet.Empty
+                        new[] { ShortDescription }
                     ));
                 }
 
@@ -304,7 +304,7 @@ private OverloadResult GetNewOverloadResult(OverloadResult overload) {
                 overload.Parameters.RemoveFirst(),
                 ClassDefinition.Name,
                 string.IsNullOrEmpty(doc) ? Documentation : doc,
-                overload.ReturnTypes
+                overload.ReturnType
             );
         }
 
@@ -314,7 +314,7 @@ private OverloadResult GetInitOverloadResult(OverloadResult overload) {
                 overload.Parameters.RemoveFirst(),
                 ClassDefinition.Name,
                 string.IsNullOrEmpty(doc) ? Documentation : doc,
-                overload.ReturnTypes
+                overload.ReturnType
             );
         }
 

src/Analysis/Engine/Impl/Values/FunctionInfo.cs

@@ -485,12 +485,13 @@ public override IEnumerable<OverloadResult> Overloads {
                             LazyCallArgs = new Lazy<ArgumentSet>(() => new ArgumentSet(vars, null, null, null)),
                             ResolveFully = true
                         }, out _)
+                        .GetShortDescriptions()
                         .ToArray();
 
                     bool needNewSet = true;
                     foreach (var set in parameterSets) {
                         if (set.ParameterCount == names.Length) {
-                            if (set.TryAddOverload(null, null, names, vars, defaults, AnalysisSet.Create(rtypes))) {
+                            if (set.TryAddOverload(null, null, names, vars, defaults, rtypes)) {
                                 needNewSet = false;
                                 break;
                             }
@@ -500,7 +501,7 @@ public override IEnumerable<OverloadResult> Overloads {
                     if (needNewSet) {
                         var set = new AccumulatedOverloadResult(FunctionDefinition.Name, Documentation, names.Length);
                         parameterSets.Add(set);
-                        set.TryAddOverload(null, null, names, vars, defaults, AnalysisSet.Create(rtypes));
+                        set.TryAddOverload(null, null, names, vars, defaults, rtypes);
                     }
                 }
 

src/Analysis/Engine/Impl/Values/Protocols.cs

@@ -187,7 +187,7 @@ protected override void EnsureMembers(IDictionary<string, IAnalysisSet> members)
 
         private OverloadResult[] GenerateOverloads() {
             return new[] {
-                new OverloadResult(Arguments.Select(ToParameterResult).ToArray(), Name, null, ReturnType)
+                new OverloadResult(Arguments.Select(ToParameterResult).ToArray(), Name, null, ReturnType.GetShortDescriptions())
             };
         }
 

src/Analysis/Engine/Test/TypeAnnotationTests.cs

@@ -391,7 +391,7 @@ def scale(scalar: float, vector: Vector) -> Vector:
 new_vector = scale(2.0, [1.0, -4.2, 5.4])
 ",
                 new[] {
-                    "scale:scale(scalar:float, vector:list[float]) -> list[float]"
+                    "scale:scale(scalar:float, vector:list[float, float, float], list[float]) -> list[float]"
                 }
             );
         }
@@ -438,7 +438,7 @@ def get_user_name(user_id: UserId) -> str:
 user_b = get_user_name(-1)
 ",
                 new[] {
-                    "get_user_name:get_user_name(user_id:int) -> str"
+                    "get_user_name:get_user_name(user_id:int, UserId) -> str"
                 }
             );
         }
@@ -543,7 +543,7 @@ def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:
         var.set(0)
 ",
                 new[] {
-                    "LoggedVar.set:set(self:LoggedVar, new:T) -> None",
+                    "LoggedVar.set:set(self:LoggedVar, new:int, T) -> None",
                     "zero_all_vars:zero_all_vars(vars:iterable[LoggedVar]) -> None"
                 }
             );
@@ -553,13 +553,13 @@ def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:
         public async Task TypingModuleDocumentationExample_10() {
             await TypingModuleDocumentationExampleAsync(@"from typing import NewType
 
-UserId = NewType('UserId', int)
+UserId = NewType('UserId', float)
 
-def f(u : UserId=345, a : float=1.0):
+def f(u : UserId=345., a : float=1.0):
     return u
 ",
                 new[] {
-                    "f:f(u:int=345, a:float=1.0) -> UserId"
+                    "f:f(u:float, UserId=345.0, a:float=1.0) -> [float, UserId]"
                 }
             );
         }