Properly generate parameter types

Author: MikhailArkhipov

src/Analysis/Engine/Impl/OverloadResult.cs

@@ -144,15 +144,15 @@ class AccumulatedOverloadResult {
         private string _name;
         private string _doc;
         private string[] _pnames;
-        private IAnalysisSet[] _ptypes;
+        private string[] _ptypes;
         private string[] _pdefaults;
         private readonly HashSet<string> _rtypes;
 
         public AccumulatedOverloadResult(string name, string documentation, int parameters) {
             _name = name;
             _doc = documentation;
             _pnames = new string[parameters];
-            _ptypes = new IAnalysisSet[parameters];
+            _ptypes = new string[parameters];
             _pdefaults = new string[parameters];
             ParameterCount = parameters;
             _rtypes = new HashSet<string>();
@@ -181,15 +181,15 @@ private string ChooseBest(string x, string y) {
 
         private IAnalysisSet ChooseBest(IAnalysisSet x, IAnalysisSet y) {
             if (x == null || x.IsObjectOrUnknown()) {
-                return (y == null) ? AnalysisSet.Empty : y;
+                return (y == null || y.IsObjectOrUnknown()) ? AnalysisSet.Empty : y;
             }
             if (y == null || y.IsObjectOrUnknown()) {
                 return AnalysisSet.Empty;
             }
             return x.Union(y);
         }
 
-        public bool TryAddOverload(string name, string documentation, string[] names, IAnalysisSet[] types, string[] defaults, IEnumerable<string> returnTypes) {
+        public bool TryAddOverload(string name, string documentation, string[] names, string[] types, string[] defaults, IEnumerable<string> returnTypes) {
             if (names.Length != _pnames.Length || types.Length != _ptypes.Length) {
                 return false;
             }
@@ -233,7 +233,7 @@ public OverloadResult ToOverloadResult() {
                 parameters[i] = new ParameterResult(
                     _pnames[i],
                     null,
-                    (_ptypes[i] == null || _ptypes[i].IsObjectOrUnknown()) ? null : string.Join(", ", _ptypes[i].GetShortDescriptions()),
+                    _ptypes[i],
                     false,
                     null,
                     _pdefaults[i]

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

@@ -337,9 +337,6 @@ internal override AnalysisValue UnionMergeTypes(AnalysisValue ns, int strength)
                 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;
             }

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

@@ -466,27 +466,9 @@ public override IEnumerable<OverloadResult> Overloads {
 
                 foreach (var unit in units) {
                     var names = FunctionDefinition.Parameters.Select(MakeParameterName).ToArray();
-
-                    var vars = FunctionDefinition.Parameters.Select(p => {
-                        if (unit != AnalysisUnit && unit.InterpreterScope.TryGetVariable(p.Name, out var param)) {
-                            return param.Types.Resolve(unit);
-                        } else if (_analysisUnit._scope is FunctionScope fs) {
-                            return fs.GetParameter(p.Name)?.Types.Resolve(unit) ?? AnalysisSet.Empty;
-                        }
-                        return AnalysisSet.Empty;
-                    }).ToArray();
-
+                    var vars = FunctionDefinition.Parameters.Select(p => GetAnnotation(ProjectState, p, DeclaringModule.Tree)).ToArray();
                     var defaults = FunctionDefinition.Parameters.Select(p => GetDefaultValue(unit.State, p, DeclaringModule.Tree)).ToArray();
-
-                    var rtypes = (unit.Scope as FunctionScope)?.ReturnValue
-                        .Types
-                        .Resolve(unit, new ResolutionContext {
-                            Caller = this,
-                            LazyCallArgs = new Lazy<ArgumentSet>(() => new ArgumentSet(vars, null, null, null)),
-                            ResolveFully = true
-                        }, out _)
-                        .GetShortDescriptions()
-                        .ToArray();
+                    var rtypes = GetReturnValue().GetShortDescriptions().ToArray();
 
                     bool needNewSet = true;
                     foreach (var set in parameterSets) {

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, float, float], list[float]) -> list[float]"
+                    "scale:scale(scalar:float, vector: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, UserId) -> str"
+                    "get_user_name:get_user_name(user_id: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:int, T) -> None",
+                    "LoggedVar.set:set(self:LoggedVar, new:T) -> None",
                     "zero_all_vars:zero_all_vars(vars:iterable[LoggedVar]) -> None"
                 }
             );