Switches indexing from using an object parameter to an argument set parameter (microsoft#1266)

* Switching out index calls to use ArgumentSet instead of object as index
parameter

Author: CTrando

src/Analysis/Ast/Impl/Analyzer/Evaluation/ExpressionEval.Collections.cs

@@ -49,7 +49,7 @@ public IMember GetValueFromIndex(IndexExpression expr) {
                 }
                 var index = GetValueFromExpression(expr.Index);
                 if (index != null) {
-                    return type.Index(instance, index);
+                    return type.Index(instance, new ArgumentSet(new []{index}, expr, this));
                 }
             }
 

src/Analysis/Ast/Impl/Modules/PythonModule.cs

@@ -125,7 +125,7 @@ internal PythonModule(ModuleCreationOptions creationOptions, IServiceContainer s
         public IMember CreateInstance(string typeName, IArgumentSet args) => this;
         public override PythonMemberType MemberType => PythonMemberType.Module;
         public IMember Call(IPythonInstance instance, string memberName, IArgumentSet args) => GetMember(memberName);
-        public IMember Index(IPythonInstance instance, object index) => Interpreter.UnknownType;
+        public IMember Index(IPythonInstance instance, IArgumentSet args) => Interpreter.UnknownType;
 
         public virtual string Documentation {
             get {

src/Analysis/Ast/Impl/Modules/PythonVariableModule.cs

@@ -67,7 +67,7 @@ public PythonVariableModule(IPythonModule module): base(module) {
         public IEnumerable<string> GetMemberNames() => Module != null ? Module.GetMemberNames().Concat(_children.Keys) : _children.Keys;
 
         public IMember Call(IPythonInstance instance, string memberName, IArgumentSet args) => GetMember(memberName);
-        public IMember Index(IPythonInstance instance, object index) => Interpreter.UnknownType;
+        public IMember Index(IPythonInstance instance, IArgumentSet args) => Interpreter.UnknownType;
         public IMember CreateInstance(string typeName = null, IArgumentSet args = null) => this;
 
         public bool Equals(IPythonModule other) => other is PythonVariableModule module && Name.EqualsOrdinal(module.Name);

src/Analysis/Ast/Impl/Specializations/Typing/Types/AnyType.cs

@@ -37,7 +37,7 @@ public IMember Call(IPythonInstance instance, string memberName, IArgumentSet ar
         public IMember GetMember(string name) => null;
         public IEnumerable<string> GetMemberNames() => Array.Empty<string>();
 
-        public IMember Index(IPythonInstance instance, object index)
+        public IMember Index(IPythonInstance instance, IArgumentSet args)
             => DeclaringModule.Interpreter.UnknownType;
     }
 }

src/Analysis/Ast/Impl/Specializations/Typing/Types/GenericType.cs

@@ -100,7 +100,7 @@ public IMember CreateInstance(string typeName, IArgumentSet args) {
         }
 
         public virtual IMember Call(IPythonInstance instance, string memberName, IArgumentSet args) => DeclaringModule.Interpreter.UnknownType;
-        public virtual IMember Index(IPythonInstance instance, object index) => DeclaringModule.Interpreter.UnknownType;
+        public virtual IMember Index(IPythonInstance instance, IArgumentSet args) => DeclaringModule.Interpreter.UnknownType;
 
         public IPythonType CreateSpecificType(IArgumentSet typeArguments)
             => CreateSpecificType(typeArguments.Arguments.Select(a => a.Value).OfType<IPythonType>().ToArray());

src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingDictionaryType.cs

@@ -47,7 +47,7 @@ public TypingDictionaryType(string name, IPythonType keyType, IPythonType valueT
         public override string Name { get; }
 
         public override IMember CreateInstance(string typeName, IArgumentSet args) => new TypingDictionary(this);
-        public override IMember Index(IPythonInstance instance, object index) => new PythonInstance(ValueType);
+        public override IMember Index(IPythonInstance instance, IArgumentSet args) => new PythonInstance(ValueType);
         public override bool IsSpecialized => true;
 
         private TypingTupleType CreateItemType() {

src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingListType.cs

@@ -53,7 +53,7 @@ public TypingListType(string typeName, BuiltinTypeId typeId, IPythonType itemTyp
         public override IMember CreateInstance(string typeName, IArgumentSet args) => new TypingList(this);
         public IPythonType ItemType { get; }
 
-        public override IMember Index(IPythonInstance instance, object index) => new PythonInstance(ItemType);
+        public override IMember Index(IPythonInstance instance, IArgumentSet args) => new PythonInstance(ItemType);
 
         public override bool Equals(object obj) {
             if (!(obj is TypingListType other)) {

src/Analysis/Ast/Impl/Specializations/Typing/Types/TypingTupleType.cs

@@ -44,8 +44,8 @@ public TypingTupleType(IReadOnlyList<IPythonType> itemTypes, IPythonInterpreter
         public override IMember CreateInstance(string typeName, IArgumentSet args)
             => new TypingTuple(this);
 
-        public override IMember Index(IPythonInstance instance, object index) {
-            var n = PythonCollection.GetIndex(index);
+        public override IMember Index(IPythonInstance instance, IArgumentSet args) {
+            var n = PythonCollection.GetIndex(args);
             if (n < 0) {
                 n = ItemTypes.Count + n; // -1 means last, etc.
             }

src/Analysis/Ast/Impl/Specializations/Typing/Values/TypingDictionary.cs

@@ -37,7 +37,7 @@ public override IPythonIterator GetIterator() {
             return new TypingIterator(iteratorType, this);
         }
 
-        public override IMember Index(object key) => new PythonInstance(_dictType.ValueType);
+        public override IMember Index(IArgumentSet args) => new PythonInstance(_dictType.ValueType);
 
         public override IMember Call(string memberName, IArgumentSet args) {
             // Specializations

src/Analysis/Ast/Impl/Specializations/Typing/Values/TypingList.cs

@@ -34,6 +34,6 @@ public override IPythonIterator GetIterator() {
             return new TypingIterator(iteratorType, this);
         }
 
-        public override IMember Index(object index) => _collectionType.Index(this, index);
+        public override IMember Index(IArgumentSet args) => _collectionType.Index(this, args);
     }
 }

src/Analysis/Ast/Impl/Specializations/Typing/Values/TypingTuple.cs

@@ -32,7 +32,7 @@ public override IPythonIterator GetIterator() {
             return new TypingIterator(iteratorType, this);
         }
 
-        public override IMember Index(object index) 
-            => _collectionType.Index(this, index).GetPythonType().CreateInstance(null, ArgumentSet.WithoutContext);
+        public override IMember Index(IArgumentSet args) 
+            => _collectionType.Index(this, args).GetPythonType().CreateInstance(null, ArgumentSet.Empty(args.Expression, args.Eval));
     }
 }

src/Analysis/Ast/Impl/Specializations/Typing/Values/TypingType.cs

@@ -42,6 +42,6 @@ public TypingType(IPythonModule declaringModule, IPythonType type): base(declari
         public IMember CreateInstance(string typeName, IArgumentSet args) => _type;
         public IMember GetMember(string name) => _type.GetMember(name);
         public IEnumerable<string> GetMemberNames() => _type.GetMemberNames();
-        public IMember Index(IPythonInstance instance, object index) => _type.Index(instance, index);
+        public IMember Index(IPythonInstance instance, IArgumentSet args) => _type.Index(instance, args);
     }
 }

src/Analysis/Ast/Impl/Types/Collections/PythonCollectionType.cs

@@ -78,8 +78,8 @@ public override IMember CreateInstance(string typeName, IArgumentSet args)
         public override IMember Call(IPythonInstance instance, string memberName, IArgumentSet args)
             => DeclaringModule.Interpreter.GetBuiltinType(TypeId)?.Call(instance, memberName, args);
 
-        public override IMember Index(IPythonInstance instance, object index)
-            => (instance as IPythonCollection)?.Index(index) ?? UnknownType;
+        public override IMember Index(IPythonInstance instance, IArgumentSet args)
+            => (instance as IPythonCollection)?.Index(args) ?? UnknownType;
         #endregion
 
 

src/Analysis/Ast/Impl/Types/Definitions/IPythonType.cs

@@ -72,6 +72,6 @@ public interface IPythonType : ILocatedMember, IMemberContainer {
         /// </summary>
         /// <param name="instance">Instance of the type.</param>
         /// <param name="index">Index arguments.</param>
-        IMember Index(IPythonInstance instance, object index);
+        IMember Index(IPythonInstance instance, IArgumentSet args);
     }
 }

src/Analysis/Ast/Impl/Types/PythonClassType.cs

@@ -151,11 +151,11 @@ public override IMember CreateInstance(string typeName, IArgumentSet args) {
             return new PythonInstance(this);
         }
 
-        public override IMember Index(IPythonInstance instance, object index) {
-            var defaultReturn = base.Index(instance, index);
+        public override IMember Index(IPythonInstance instance, IArgumentSet args) {
+            var defaultReturn = base.Index(instance, args);
             var fromBases = Bases
                 .MaybeEnumerate()
-                .Select(b => b.Index(instance, index))
+                .Select(b => b.Index(instance, args))
                 .Except(new[] { defaultReturn, UnknownType })
                 .FirstOrDefault();
 

src/Analysis/Ast/Impl/Types/PythonType.cs

@@ -84,7 +84,7 @@ public virtual IMember Call(IPythonInstance instance, string memberName, IArgume
         /// </summary>
         /// <param name="instance">Instance of the type.</param>
         /// <param name="index">Index arguments.</param>
-        public virtual IMember Index(IPythonInstance instance, object index) => instance?.Index(index) ?? UnknownType;
+        public virtual IMember Index(IPythonInstance instance, IArgumentSet args) => instance?.Index(args) ?? UnknownType;
         #endregion
 
         #region IMemberContainer

src/Analysis/Ast/Impl/Types/PythonTypeWrapper.cs

@@ -69,8 +69,8 @@ public virtual IMember CreateInstance(string typeName, IArgumentSet args)
             => IsAbstract ? null : InnerType.CreateInstance(typeName, args);
         public virtual IMember Call(IPythonInstance instance, string memberName, IArgumentSet args) 
             => InnerType.Call(instance, memberName, args);
-        public virtual IMember Index(IPythonInstance instance, object index) 
-            => InnerType.Index(instance, index);
+        public virtual IMember Index(IPythonInstance instance, IArgumentSet args) 
+            => InnerType.Index(instance, args);
         #endregion
 
         #region ILocatedMember

src/Analysis/Ast/Impl/Types/PythonUnionType.cs

@@ -77,14 +77,14 @@ public IMember Call(IPythonInstance instance, string memberName, IArgumentSet ar
             return result ?? DeclaringModule.Interpreter.UnknownType;
         }
 
-        public IMember Index(IPythonInstance instance, object index) {
+        public IMember Index(IPythonInstance instance, IArgumentSet args) {
             IPythonType[] types;
             lock (_lock) {
                 types = _types.ToArray();
             }
             // Check if any types support indexing
             var result = types
-                    .Select(t => t.Index(instance, index))
+                    .Select(t => t.Index(instance, args))
                     .FirstOrDefault(r => !r.IsUnknown() && r.GetPythonType() != this);
             return result ?? DeclaringModule.Interpreter.UnknownType;
         }

src/Analysis/Ast/Impl/Values/Collections/PythonCollection.cs

@@ -46,8 +46,8 @@ public PythonCollection(
         /// <summary>
         /// Invokes indexer the instance.
         /// </summary>
-        public override IMember Index(object index) {
-            var n = GetIndex(index);
+        public override IMember Index(IArgumentSet args) {
+            var n = GetIndex(args);
             if (n < 0) {
                 n = Contents.Count + n; // -1 means last, etc.
             }
@@ -60,8 +60,14 @@ public override IMember Index(object index) {
         public IReadOnlyList<IMember> Contents { get; protected set; }
         public override IPythonIterator GetIterator() => new PythonIterator(BuiltinTypeId.ListIterator, this);
 
-        public static int GetIndex(object index) {
-            switch (index) {
+        public static int GetIndex(IArgumentSet args) {
+            // syntax error 
+            if (args.Arguments.Count != 1) {
+                return 0;
+            }
+
+            var arg = args.Arguments[0].Value;
+            switch (arg) {
                 case IPythonConstant c when c.Type.TypeId == BuiltinTypeId.Int || c.Type.TypeId == BuiltinTypeId.Long:
                     return (int)c.Value;
                 case int i:

src/Analysis/Ast/Impl/Values/Collections/PythonDictionary.cs

@@ -64,13 +64,24 @@ public IReadOnlyList<IPythonCollection> Items
         public override IPythonIterator GetIterator() =>
             Call(@"iterkeys", ArgumentSet.WithoutContext) as IPythonIterator ?? new EmptyIterator(Type.DeclaringModule.Interpreter.UnknownType);
 
-        public override IMember Index(object key) => key is IMember m ? this[m] : UnknownType;
+        public override IMember Index(IArgumentSet args) {
+            if (args.Arguments.Count == 1) {
+                return args.Arguments[0].Value is IMember m ? this[m] : UnknownType;
+            }
+            return UnknownType;
+        }
 
         public override IMember Call(string memberName, IArgumentSet args) {
             // Specializations
             switch (memberName) {
                 case @"get":
-                    return args.Arguments.Count > 1 ? Index(args.Arguments[1].Value) : _interpreter.UnknownType;
+                    // d = {}
+                    // d.get("test", 3.14), 3.14 is the default value so we infer the type of the return from it
+                    if (args.Arguments.Count > 1) {
+                        var defaultArg = args.Arguments[1].Value as IMember;
+                        return Index(new ArgumentSet(new List<IMember>() { defaultArg }, args.Expression, args.Eval));
+                    }
+                    return _interpreter.UnknownType;
                 case @"items":
                     return CreateList(Items);
                 case @"keys":

src/Analysis/Ast/Impl/Values/Collections/PythonInstanceIterator.cs

@@ -53,7 +53,7 @@ public EmptyIterator(IPythonType unknownType): base(PythonMemberType.Class) {
         public IPythonIterator GetIterator() => this;
         public IPythonType Type { get; }
         public IMember Call(string memberName, IArgumentSet args) => Type;
-        public IMember Index(object index) => Type;
+        public IMember Index(IArgumentSet args) => Type;
         public IMember Next => Type;
     }
 }

src/Analysis/Ast/Impl/Values/Collections/PythonIterator.cs

@@ -14,6 +14,7 @@
 // permissions and limitations under the License.
 
 using Microsoft.Python.Analysis.Types;
+using System.Collections.Generic;
 
 namespace Microsoft.Python.Analysis.Values.Collections {
     /// <summary>
@@ -33,7 +34,12 @@ public PythonIterator(IPythonType iteratorType, IPythonCollection collection) :
             Collection = collection;
         }
 
-        public virtual IMember Next => Collection.Index(_index++) ?? UnknownType;
+        public virtual IMember Next => Collection.Index(GetArgSet(_index++)) ?? UnknownType;
+
+        private IArgumentSet GetArgSet(int index) {
+            var newArg = new PythonConstant(index, Type.DeclaringModule.Interpreter.GetBuiltinType(BuiltinTypeId.Int));
+            return new ArgumentSet(new List<IMember>() { newArg }, null, null);
+        }
 
         public override IMember Call(string memberName, IArgumentSet args) {
             // Specializations

src/Analysis/Ast/Impl/Values/Definitions/IPythonInstance.cs

@@ -35,6 +35,6 @@ public interface IPythonInstance : IMember, IPythonIterable {
         /// <summary>
         /// Invokes indexer the instance.
         /// </summary>
-        IMember Index(object index);
+        IMember Index(IArgumentSet args);
     }
 }

src/Analysis/Ast/Impl/Values/PythonInstance.cs

@@ -49,7 +49,7 @@ public virtual IMember Call(string memberName, IArgumentSet args) {
             return null;
         }
 
-        public virtual IMember Index(object index) => this; // Helps with str slicing
+        public virtual IMember Index(IArgumentSet args) => this; // Helps with str slicing
 
         protected IMember UnknownType => Type.DeclaringModule.Interpreter.UnknownType;