Split method

Author: MikhailArkhipov

src/Analysis/Engine/Impl/ModuleAnalysis.cs

@@ -113,7 +113,7 @@ private static IAnalysisSet ResolveAndAdd(AnalysisUnit unit, IAnalysisSet set, A
             return set.Union(value.Resolve(unit));
         }
 
-        internal IEnumerable<AnalysisVariable> ToVariables(IReferenceable referenceable) {
+        internal static IEnumerable<AnalysisVariable> ToVariables(IReferenceable referenceable) {
             var def = referenceable as VariableDef;
 
             if (def != null) {
@@ -210,10 +210,22 @@ public VariablesResult GetVariables(Expression expr, SourceLocation location, st
 
             var unit = GetNearestEnclosingAnalysisUnit(scope);
             var tree = unit.Tree;
-
             var eval = new ExpressionEvaluator(unit.CopyForEval(), scope, mergeScopes: true);
-            var variables = Enumerable.Empty<IAnalysisVariable>();
 
+            var result = GetVariablesFromCallExpression(unit, eval, scope, location, originalText);
+            if (result != null) {
+                return result;
+            }
+
+            result = GetVariablesFromNameExpression(expr, unit, scope);
+            if (result != null) {
+                return result;
+            }
+
+            return GetVariablesFromMemberExpression(expr, unit, eval);
+        }
+
+        private static VariablesResult GetVariablesFromCallExpression(AnalysisUnit unit, ExpressionEvaluator eval, IScope scope, SourceLocation location, string originalText) {
             var finder = new ExpressionFinder(unit.Tree, new GetExpressionOptions { Calls = true });
             var callNode = finder.GetExpression(location) as CallExpression;
             if (callNode != null) {
@@ -231,42 +243,52 @@ public VariablesResult GetVariables(Expression expr, SourceLocation location, st
                         unit.Tree);
                 }
             }
+            return null;
+        }
 
-            if (expr is NameExpression name) {
-                if (!scope.EnumerateTowardsGlobal.Any()) {
-                    variables = _unit.State.BuiltinModule.GetDefinitions(name.Name).SelectMany(ToVariables);
-                } else {
-                    foreach (var s in scope.EnumerateTowardsGlobal) {
-                        var scopeVariables = GetVariablesInScope(name, s).Distinct();
-                        variables = variables.Union(scopeVariables);
-                        var args = scopeVariables.Where(v => IsFunctionArgument(s, v));
-                        if (args.Any()) {
-                            break;
-                        }
-                    }
+        private VariablesResult GetVariablesFromNameExpression(Expression expr, AnalysisUnit unit, IScope scope) {
+            if (!(expr is NameExpression name)) {
+                return null;
+            }
 
-                    // Now take outermost definition and treat inner ones (such as reassignments) as references
-                    var others = variables.Where(v => v.Type == VariableType.Reference || v.Type == VariableType.Value);
-                    var definitions = variables
-                        .Where(v => v.Type == VariableType.Definition)
-                        .OrderBy(v => v.Location.Span.Start)
-                        .ToArray();
+            var variables = Enumerable.Empty<IAnalysisVariable>();
+            if (!scope.EnumerateTowardsGlobal.Any()) {
+                variables = _unit.State.BuiltinModule.GetDefinitions(name.Name).SelectMany(ToVariables);
+                return new VariablesResult(variables, unit.Tree);
+            }
 
-                    if (definitions.Length > 0) {
-                        var defsToRefs = definitions.Skip(1).Select(v => new AnalysisVariable(v.Variable, VariableType.Reference, v.Location));
-                        variables = definitions.Take(1).Concat(others.Concat(defsToRefs));
-                    }
+            foreach (var s in scope.EnumerateTowardsGlobal) {
+                var scopeVariables = GetVariablesInScope(name, s).Distinct();
+                variables = variables.Union(scopeVariables);
+                var args = scopeVariables.Where(v => IsFunctionArgument(s, v));
+                if (args.Any()) {
+                    break;
                 }
-                return new VariablesResult(variables, unit.Tree);
             }
 
+            // Now take outermost definition and treat inner ones (such as reassignments) as references
+            var others = variables.Where(v => v.Type == VariableType.Reference || v.Type == VariableType.Value);
+            var definitions = variables
+                .Where(v => v.Type == VariableType.Definition)
+                .OrderBy(v => v.Location.Span.Start)
+                .ToArray();
+
+            if (definitions.Length > 0) {
+                var defsToRefs = definitions.Skip(1).Select(v => new AnalysisVariable(v.Variable, VariableType.Reference, v.Location));
+                variables = definitions.Take(1).Concat(others.Concat(defsToRefs));
+            }
+
+            return new VariablesResult(variables, unit.Tree);
+        }
+
+        private VariablesResult GetVariablesFromMemberExpression(Expression expr, AnalysisUnit unit, ExpressionEvaluator eval) {
+            var variables = Enumerable.Empty<IAnalysisVariable>();
             if (expr is MemberExpression member && !string.IsNullOrEmpty(member.Name)) {
                 var objects = eval.Evaluate(member.Target);
                 foreach (var v in objects.OfType<IReferenceableContainer>()) {
                     variables = variables.Union(v.GetDefinitions(member.Name).SelectMany(ToVariables));
                 }
             }
-
             return new VariablesResult(variables, unit.Tree);
         }
 
@@ -282,7 +304,7 @@ private bool IsFunctionArgument(IScope scope, IAnalysisVariable v) {
             return false;
         }
 
-        private IEnumerable<IAnalysisVariable> GetVariablesInScope(NameExpression name, IScope scope) {
+        private static IEnumerable<IAnalysisVariable> GetVariablesInScope(NameExpression name, IScope scope) {
             var result = new List<IAnalysisVariable>();
 
             result.AddRange(scope.GetMergedVariables(name.Name).SelectMany(ToVariables));