Find all references and rename

TROUBLESHOOTING.md

@@ -9,9 +9,6 @@ in [Filing an issue](#filing-an-issue).
 
 There are a few known issues in the current version of the language server:
 
-- Find references and rename functionality is not yet implemented.
-    - See [#699](https://github.com/Microsoft/python-language-server/issues/699),
-    [#577](https://github.com/Microsoft/python-language-server/issues/577).
 - Not all `__all__` statements can be handled.
     - Some modules may have an incorrect list of exported names.
     See [#620](https://github.com/Microsoft/python-language-server/issues/620),

src/Analysis/Ast/Impl/Analyzer/AnalysisWalker.cs

@@ -64,6 +64,13 @@ public override bool Walk(ExpressionStatement node) {
                 case Comprehension comp:
                     Eval.ProcessComprehension(comp);
                     return false;
+                case CallExpression callex when callex.Target is NameExpression nex && !string.IsNullOrEmpty(nex.Name):
+                    Eval.LookupNameInScopes(nex.Name)?.AddReference(Eval.GetLocationOfName(nex));
+                    return false;
+                case CallExpression callex when callex.Target is MemberExpression mex && !string.IsNullOrEmpty(mex.Name):
+                    var t = Eval.GetValueFromExpression(mex.Target)?.GetPythonType();
+                    t?.GetMember(mex.Name).AddReference(Eval.GetLocationOfName(mex));
+                    return false;
                 default:
                     return base.Walk(node);
             }

src/Analysis/Ast/Impl/Analyzer/Definitions/IAnalyzable.cs

@@ -13,13 +13,16 @@
 // See the Apache Version 2.0 License for specific language governing
 // permissions and limitations under the License.
 
-using System;
-
 namespace Microsoft.Python.Analysis.Analyzer {
     /// <summary>
     /// Represents document that can be analyzed asynchronously.
     /// </summary>
     internal interface IAnalyzable {
+        /// <summary>
+        /// Notifies document that analysis is about to begin.
+        /// </summary>
+        void NotifyAnalysisBegins();
+
         /// <summary>
         /// Notifies document that its analysis is now complete.
         /// </summary>

src/Analysis/Ast/Impl/Analyzer/Definitions/IExpressionEvaluator.cs

@@ -15,7 +15,6 @@
 
 using System;
 using System.Collections.Generic;
-using Microsoft.Python.Analysis.Analyzer.Evaluation;
 using Microsoft.Python.Analysis.Diagnostics;
 using Microsoft.Python.Analysis.Types;
 using Microsoft.Python.Analysis.Values;
@@ -56,18 +55,39 @@ public interface IExpressionEvaluator {
         /// <summary>
         /// Evaluates expression in the currently open scope.
         /// </summary>
-        IMember GetValueFromExpression(Expression expr);
+        IMember GetValueFromExpression(Expression expr, LookupOptions options = LookupOptions.Normal);
 
-        IMember LookupNameInScopes(string name, out IScope scope, LookupOptions options = LookupOptions.Normal);
+        IMember LookupNameInScopes(string name, out IScope scope, out IVariable v, LookupOptions options = LookupOptions.Normal);
 
         IPythonType GetTypeFromString(string typeString);
 
+        /// <summary>
+        /// Module AST.
+        /// </summary>
         PythonAst Ast { get; }
+
+        /// <summary>
+        /// Associated module.
+        /// </summary>
         IPythonModule Module { get; }
+
+        /// <summary>
+        /// Interpreter used in the module analysis.
+        /// </summary>
         IPythonInterpreter Interpreter { get; }
+
+        /// <summary>
+        /// Application service container.
+        /// </summary>
         IServiceContainer Services { get; }
 
         void ReportDiagnostics(Uri documentUri, DiagnosticsEntry entry);
+
         IEnumerable<DiagnosticsEntry> Diagnostics { get; }
+
+        /// <summary>
+        /// Represents built-in 'unknown' type. <see cref="BuiltinTypeId.Unknown"/>.
+        /// </summary>
+        IPythonType UnknownType { get; }
     }
 }

src/Analysis/Ast/Impl/Analyzer/Definitions/IPythonAnalyzer.cs

@@ -59,5 +59,10 @@ public interface IPythonAnalyzer {
         /// Removes all the modules from the analysis, except Typeshed and builtin
         /// </summary>
         void ResetAnalyzer();
+
+        /// <summary>
+        /// Returns list of currently loaded modules.
+        /// </summary>
+        IReadOnlyList<IPythonModule> LoadedModules { get; }
     }
 }

src/Analysis/Ast/Impl/Analyzer/Definitions/LookupOptions.cs

@@ -19,10 +19,10 @@ namespace Microsoft.Python.Analysis.Analyzer {
     [Flags]
     public enum LookupOptions {
         None = 0,
-        Local,
-        Nonlocal,
-        Global,
-        Builtins,
+        Local = 1,
+        Nonlocal = 2,
+        Global = 4,
+        Builtins = 8,
         Normal = Local | Nonlocal | Global | Builtins
     }
 }

src/Analysis/Ast/Impl/Analyzer/DocumentAnalysis.cs

@@ -86,7 +86,7 @@ public EmptyAnalysis(IServiceContainer services, IDocument document) {
             Document = document ?? throw new ArgumentNullException(nameof(document));
             GlobalScope = new EmptyGlobalScope(document);
 
-            _emptyAst = _emptyAst ?? (_emptyAst = Parser.CreateParser(new StringReader(string.Empty), PythonLanguageVersion.None).ParseFile());
+            _emptyAst = _emptyAst ?? (_emptyAst = Parser.CreateParser(new StringReader(string.Empty), PythonLanguageVersion.None).ParseFile(document.Uri));
             ExpressionEvaluator = new ExpressionEval(services, document, Ast);
         }
 

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

@@ -32,6 +32,8 @@ public IMember GetValueFromCallable(CallExpression expr) {
             }
 
             var target = GetValueFromExpression(expr.Target);
+            target?.AddReference(GetLocationOfName(expr.Target));
+
             var result = GetValueFromGeneric(target, expr);
             if (result != null) {
                 return result;
@@ -58,7 +60,7 @@ public IMember GetValueFromCallable(CallExpression expr) {
                 case IPythonType t:
                     // Target is type (info), the call creates instance.
                     // For example, 'x = C; y = x()' or 'x = C()' where C is class
-                    value = new PythonInstance(t, GetLoc(expr));
+                    value = new PythonInstance(t);
                     break;
             }
 
@@ -74,9 +76,9 @@ public IMember GetValueFromLambda(LambdaExpression expr) {
                 return null;
             }
 
-            var loc = GetLoc(expr);
-            var ft = new PythonFunctionType(expr.Function, Module, null, loc);
-            var overload = new PythonFunctionOverload(expr.Function, ft, Module, GetLoc(expr));
+            var location = GetLocationOfName(expr.Function);
+            var ft = new PythonFunctionType(expr.Function, null, location);
+            var overload = new PythonFunctionOverload(expr.Function, ft, location);
             ft.AddOverload(overload);
             return ft;
         }
@@ -93,7 +95,7 @@ public IMember GetValueFromClassCtor(IPythonClassType cls, CallExpression expr)
                 }
                 args = a.Evaluate();
             }
-            return cls.CreateInstance(cls.Name, GetLoc(expr), args);
+            return cls.CreateInstance(cls.Name, args);
         }
 
         public IMember GetValueFromBound(IPythonBoundType t, CallExpression expr) {
@@ -190,7 +192,7 @@ public IMember GetValueFromFunctionType(IPythonFunctionType fn, IPythonInstance
 
             // Try and evaluate with specific arguments. Note that it does not
             // make sense to evaluate stubs since they already should be annotated.
-            if (fn.DeclaringModule is IDocument doc && fd?.IsInAst(doc.GetAnyAst()) == true) {
+            if (fn.DeclaringModule is IDocument doc && fd?.Ast == doc.GetAnyAst()) {
                 // Stubs are coming from another module.
                 return TryEvaluateWithArguments(fn.DeclaringModule, fd, args);
             }

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

@@ -60,7 +60,7 @@ public IMember GetValueFromList(ListExpression expression) {
                 var value = GetValueFromExpression(item) ?? UnknownType;
                 contents.Add(value);
             }
-            return PythonCollectionType.CreateList(Module.Interpreter, GetLoc(expression), contents, exact: true);
+            return PythonCollectionType.CreateList(Module.Interpreter, contents);
         }
 
         public IMember GetValueFromDictionary(DictionaryExpression expression) {
@@ -70,7 +70,7 @@ public IMember GetValueFromDictionary(DictionaryExpression expression) {
                 var value = GetValueFromExpression(item.SliceStop) ?? UnknownType;
                 contents[key] = value;
             }
-            return new PythonDictionary(Interpreter, GetLoc(expression), contents, exact: true);
+            return new PythonDictionary(Interpreter, contents);
         }
 
         private IMember GetValueFromTuple(TupleExpression expression) {
@@ -79,7 +79,7 @@ private IMember GetValueFromTuple(TupleExpression expression) {
                 var value = GetValueFromExpression(item) ?? UnknownType;
                 contents.Add(value);
             }
-            return PythonCollectionType.CreateTuple(Module.Interpreter, GetLoc(expression), contents, exact: true);
+            return PythonCollectionType.CreateTuple(Module.Interpreter, contents);
         }
 
         public IMember GetValueFromSet(SetExpression expression) {
@@ -88,7 +88,7 @@ public IMember GetValueFromSet(SetExpression expression) {
                 var value = GetValueFromExpression(item) ?? UnknownType;
                 contents.Add(value);
             }
-            return PythonCollectionType.CreateSet(Interpreter, GetLoc(expression), contents, exact: true);
+            return PythonCollectionType.CreateSet(Interpreter, contents);
         }
 
         public IMember GetValueFromGenerator(GeneratorExpression expression) {
@@ -108,14 +108,14 @@ public IMember GetValueFromComprehension(Comprehension node) {
                 switch (node) {
                     case ListComprehension lc:
                         var v1 = GetValueFromExpression(lc.Item) ?? UnknownType;
-                        return PythonCollectionType.CreateList(Interpreter, GetLoc(lc), new[] { v1 });
+                        return PythonCollectionType.CreateList(Interpreter, new[] { v1 });
                     case SetComprehension sc:
                         var v2 = GetValueFromExpression(sc.Item) ?? UnknownType;
-                        return PythonCollectionType.CreateSet(Interpreter, GetLoc(sc), new[] { v2 });
+                        return PythonCollectionType.CreateSet(Interpreter, new[] { v2 });
                     case DictionaryComprehension dc:
                         var k = GetValueFromExpression(dc.Key) ?? UnknownType;
                         var v = GetValueFromExpression(dc.Value) ?? UnknownType;
-                        return new PythonDictionary(new PythonDictionaryType(Interpreter), GetLoc(dc), new Dictionary<IMember, IMember> { { k, v } });
+                        return new PythonDictionary(new PythonDictionaryType(Interpreter), new Dictionary<IMember, IMember> { { k, v } });
                 }
 
                 return UnknownType;
@@ -138,20 +138,20 @@ internal void ProcessComprehension(Comprehension node) {
                 if (value != null) {
                     switch (cfor.Left) {
                         case NameExpression nex when value is IPythonCollection coll:
-                            DeclareVariable(nex.Name, coll.GetIterator().Next, VariableSource.Declaration, GetLoc(nex));
+                            DeclareVariable(nex.Name, coll.GetIterator().Next, VariableSource.Declaration, nex);
                             break;
                         case NameExpression nex:
-                            DeclareVariable(nex.Name, UnknownType, VariableSource.Declaration, GetLoc(nex));
+                            DeclareVariable(nex.Name, UnknownType, VariableSource.Declaration, nex);
                             break;
                         case TupleExpression tex when value is IPythonDictionary dict && tex.Items.Count > 0:
                             if (tex.Items[0] is NameExpression nx0 && !string.IsNullOrEmpty(nx0.Name)) {
-                                DeclareVariable(nx0.Name, dict.Keys.FirstOrDefault() ?? UnknownType, VariableSource.Declaration, GetLoc(nx0));
+                                DeclareVariable(nx0.Name, dict.Keys.FirstOrDefault() ?? UnknownType, VariableSource.Declaration, nx0);
                             }
                             if (tex.Items.Count > 1 && tex.Items[1] is NameExpression nx1 && !string.IsNullOrEmpty(nx1.Name)) {
-                                DeclareVariable(nx1.Name, dict.Values.FirstOrDefault() ?? UnknownType, VariableSource.Declaration, GetLoc(nx1));
+                                DeclareVariable(nx1.Name, dict.Values.FirstOrDefault() ?? UnknownType, VariableSource.Declaration, nx1);
                             }
                             foreach (var item in tex.Items.Skip(2).OfType<NameExpression>().Where(x => !string.IsNullOrEmpty(x.Name))) {
-                                DeclareVariable(item.Name, UnknownType, VariableSource.Declaration, GetLoc(item));
+                                DeclareVariable(item.Name, UnknownType, VariableSource.Declaration, item);
                             }
                             break;
                     }

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

@@ -24,20 +24,19 @@
 namespace Microsoft.Python.Analysis.Analyzer.Evaluation {
     internal sealed partial class ExpressionEval {
         public IPythonInstance GetConstantFromLiteral(Expression expr, LookupOptions options) {
-            var location = GetLoc(expr);
             if (expr is ConstantExpression ce) {
                 switch (ce.Value) {
                     case string s:
-                        return new PythonUnicodeString(s, Interpreter, location);
+                        return new PythonUnicodeString(s, Interpreter);
                     case AsciiString b:
-                        return new PythonAsciiString(b, Interpreter, location);
+                        return new PythonAsciiString(b, Interpreter);
                     case int integer:
-                        return new PythonConstant(integer, Interpreter.GetBuiltinType(BuiltinTypeId.Int), location);
+                        return new PythonConstant(integer, Interpreter.GetBuiltinType(BuiltinTypeId.Int));
                 }
             }
 
             var t = SuppressBuiltinLookup ? UnknownType : (GetTypeFromLiteral(expr) ?? UnknownType);
-            return new PythonInstance(t, location);
+            return new PythonInstance(t);
         }
 
         public IPythonType GetTypeFromLiteral(Expression expr) {

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

@@ -79,7 +79,7 @@ private IMember CreateSpecificTypeFromIndex(IGenericType gt, IReadOnlyList<IMemb
             if (gt.Name.EqualsOrdinal("Generic")) {
                 // Generic[T1, T2, ...] expression. Create generic base for the class.
                 if (genericTypeArgs.Length > 0) {
-                    return new GenericClassParameter(genericTypeArgs, Module, GetLoc(expr));
+                    return new GenericClassParameter(genericTypeArgs, Module);
                 } else {
                     // TODO: report too few type arguments for Generic[].
                     return UnknownType;
@@ -88,7 +88,7 @@ private IMember CreateSpecificTypeFromIndex(IGenericType gt, IReadOnlyList<IMemb
 
             // For other types just use supplied arguments
             if (indices.Count > 0) {
-                return gt.CreateSpecificType(new ArgumentSet(indices), Module, GetLoc(expr));
+                return gt.CreateSpecificType(new ArgumentSet(indices));
             }
             // TODO: report too few type arguments for the generic expression.
             return UnknownType;
@@ -127,7 +127,6 @@ private IReadOnlyList<IMember> EvaluateCallArgs(CallExpression expr) {
         private IMember CreateClassInstance(PythonClassType cls, IReadOnlyList<IMember> constructorArguments, CallExpression callExpr) {
             // Look at the constructor arguments and create argument set
             // based on the __init__ definition.
-            var location = GetLoc(callExpr);
             var initFunc = cls.GetMember(@"__init__") as IPythonFunctionType;
             var initOverload = initFunc?.DeclaringType == cls ? initFunc.Overloads.FirstOrDefault() : null;
 
@@ -136,8 +135,8 @@ private IMember CreateClassInstance(PythonClassType cls, IReadOnlyList<IMember>
                     : new ArgumentSet(constructorArguments);
 
             argSet.Evaluate();
-            var specificType = cls.CreateSpecificType(argSet, Module, location);
-            return new PythonInstance(specificType, location);
+            var specificType = cls.CreateSpecificType(argSet);
+            return new PythonInstance(specificType);
         }
 
         private ScopeStatement GetScope(IMember m) {

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

@@ -27,7 +27,7 @@ namespace Microsoft.Python.Analysis.Analyzer.Evaluation {
     /// </summary>
     internal sealed partial class ExpressionEval {
         public IPythonType GetTypeFromPepHint(Node node) {
-            var location = GetLoc(node);
+            var location = GetLocationInfo(node);
             var content = (Module as IDocument)?.Content;
             if (string.IsNullOrEmpty(content) || !location.EndLine.HasValue) {
                 return null;

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

@@ -13,8 +13,6 @@
 // See the Apache Version 2.0 License for specific language governing
 // permissions and limitations under the License.
 
-using System;
-using System.Collections.Generic;
 using Microsoft.Python.Analysis.Modules;
 using Microsoft.Python.Analysis.Types;
 using Microsoft.Python.Analysis.Types.Collections;
@@ -54,14 +52,16 @@ private IMember GetValueFromUnaryOp(UnaryExpression expr, string op) {
                     }
                 }
                 return instance is IPythonConstant c && instance.TryGetConstant<int>(out var value)
-                    ? new PythonConstant(-value, c.Type, GetLoc(expr))
+                    ? new PythonConstant(-value, c.Type)
                     : instance;
             }
             return UnknownType;
         }
 
         private IMember GetValueFromBinaryOp(Expression expr) {
-            if (expr is AndExpression) {
+            if (expr is AndExpression a) {
+                GetValueFromExpression(a.Left);
+                GetValueFromExpression(a.Right);
                 return Interpreter.GetBuiltinType(BuiltinTypeId.Bool);
             }
 
@@ -108,7 +108,6 @@ private IMember GetValueFromBinaryOp(Expression expr) {
             var left = GetValueFromExpression(binop.Left) ?? UnknownType;
             var right = GetValueFromExpression(binop.Right) ?? UnknownType;
 
-
             var rightType = right.GetPythonType();
             if (rightType?.TypeId == BuiltinTypeId.Float) {
                 return right;
@@ -131,7 +130,7 @@ private IMember GetValueFromBinaryOp(Expression expr) {
                 && leftType?.TypeId == BuiltinTypeId.List && rightType?.TypeId == BuiltinTypeId.List
                 && left is IPythonCollection lc && right is IPythonCollection rc) {
 
-                return PythonCollectionType.CreateConcatenatedList(Module.Interpreter, GetLoc(expr), lc, rc);
+                return PythonCollectionType.CreateConcatenatedList(Module.Interpreter, lc, rc);
             }
 
             return left.IsUnknown() ? right : left;