Merged PR 6: Revert "Hope it is fine"

Revert "Hope it is fine"

Reverted commit `1344a54c`.

2 files changed, 134 insertions, 10 deletions

diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptParser.cs b/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptParser.cs
index 15760c950..63d2cca5d 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptParser.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptParser.cs
@@ -131,16 +131,55 @@ namespace Tango.Scripting.Parsing
 
                     if (prop != null)
                     {
-                        vars.Add(new ScriptSymbol()
+                        var type = ReplaceFakeScript(prop.GetValue(symbol).ToString());
+
+                        ScriptSymbol varSymbol = new ScriptSymbol();
+                        varSymbol.Name = symbol.Name;
+                        varSymbol.Type = type;
+                        varSymbol.Class = ReplaceFakeScript(symbol.ContainingType?.Name);
+                        varSymbol.Kind = symbol.Kind;
+                        varSymbol.RealSymbol = symbol;
+                        varSymbol.Accessibility = symbol.DeclaredAccessibility;
+                        varSymbol.ContainingNamespace = ReplaceFakeScript(symbol.ContainingNamespace?.Name);
+                        varSymbol.Summary = GetSymbolDocumentation(symbol);
+
+                        try
                         {
-                            Name = symbol.Name,
-                            Type = ReplaceFakeScript(prop.GetValue(symbol).ToString()),
-                            Class = ReplaceFakeScript(symbol.ContainingType?.Name),
-                            Kind = symbol.Kind,
-                            Accessibility = symbol.DeclaredAccessibility,
-                            ContainingNamespace = ReplaceFakeScript(symbol.ContainingNamespace?.Name),
-                            Summary = GetSymbolDocumentation(symbol),
-                        });
+                            if (symbol.Kind == SymbolKind.Local && symbol.DeclaringSyntaxReferences.Count() > 0)
+                            {
+                                var node = symbol.DeclaringSyntaxReferences.First().GetSyntax() as VariableDeclaratorSyntax;
+
+                                if (node != null)
+                                {
+                                    varSymbol.IsUnassigned = node.Initializer == null;
+                                }
+                            }
+                        }
+                        catch { }
+
+                        try
+                        {
+                            varSymbol.Offset = symbol.Locations[0].SourceSpan.Start;
+                            varSymbol.Length = symbol.Locations[0].SourceSpan.Length;
+                        }
+                        catch { }
+
+                        vars.Add(varSymbol);
+
+                        if (type == "?")
+                        {
+                            try
+                            {
+                                var variables = GetScriptVariables(code);
+                                var variable = variables.FirstOrDefault(x => x.Name == symbol.Name);
+
+                                if (variable != null)
+                                {
+                                    varSymbol.Type = variable.Type;
+                                }
+                            }
+                            catch { }
+                        }
                     }
                 }
             }
@@ -258,7 +297,21 @@ namespace Tango.Scripting.Parsing
         {
             SyntaxTree tree = CSharpSyntaxTree.ParseText(code);
             CompilationUnitSyntax root = tree.GetCompilationUnitRoot();
-            return root.DescendantNodes().OfType<ObjectCreationExpressionSyntax>().FirstOrDefault();
+            var creationSyntax = root.DescendantNodes().OfType<ObjectCreationExpressionSyntax>().FirstOrDefault();
+            return creationSyntax;
+        }
+
+        public MethodDeclarationSyntax GetCurrentConstructionExpressionAlt(String code)
+        {
+            if (code.Contains("=") && code.Contains("new"))
+            {
+                SyntaxTree tree = CSharpSyntaxTree.ParseText(code);
+                CompilationUnitSyntax root = tree.GetCompilationUnitRoot();
+                var creationSyntax = root.DescendantNodes().OfType<MethodDeclarationSyntax>().FirstOrDefault();
+                return creationSyntax;
+            }
+
+            return null;
         }
 
         public T GetExpressionFirst<T>(String line) where T : CSharpSyntaxNode
@@ -378,5 +431,72 @@ namespace Tango.Scripting.Parsing
             var ret = root.ToFullString();
             return ret;
         }
+
+        private List<ScriptVariable> GetScriptVariables(String code)
+        {
+            List<ScriptVariable> vars = new List<ScriptVariable>();
+
+            SyntaxTree tree = CSharpSyntaxTree.ParseText(code);
+            var root = (CompilationUnitSyntax)tree.GetRoot();
+
+            List<VariableDeclaratorSyntax> variables = new List<VariableDeclaratorSyntax>();
+            FillVariables(variables, new List<SyntaxNode>(), root.Members[0]);
+            variables = variables.Distinct().ToList();
+
+            foreach (var item in variables)
+            {
+                ScriptVariable v = new ScriptVariable();
+                v.Name = item.Identifier.ToString();
+
+                if (item.Initializer.Value.GetType() == typeof(ObjectCreationExpressionSyntax))
+                {
+                    v.Type = (item.Initializer.Value as ObjectCreationExpressionSyntax).Type.ToString();
+                }
+                else if (item.Initializer.Value.GetType() == typeof(InvocationExpressionSyntax))
+                {
+                    v.Type = (((item.Initializer.Value as InvocationExpressionSyntax).Expression as MemberAccessExpressionSyntax).Name as GenericNameSyntax).TypeArgumentList.Arguments[0].ToString();
+                }
+
+                vars.Add(v);
+            }
+
+            return vars;
+        }
+
+        private void FillVariables(List<VariableDeclaratorSyntax> variables, List<SyntaxNode> existingNodes, SyntaxNode node)
+        {
+            var nodes = node.ChildNodes().ToList();
+
+            nodes.RemoveAll(x => existingNodes.Contains(x));
+
+            foreach (var item in nodes)
+            {
+                existingNodes.Add(item);
+
+                if (item.GetType() == typeof(VariableDeclaratorSyntax))
+                {
+                    variables.Add(item as VariableDeclaratorSyntax);
+                }
+                else if (item == node)
+                {
+                    continue;
+                }
+                else
+                {
+                    FillVariables(variables, existingNodes, item);
+                }
+            }
+        }
+
+        private class ScriptVariable
+        {
+            public String Name { get; set; }
+            public String Type { get; set; }
+
+            public override string ToString()
+            {
+                return String.Format("{0} : {1}", Type, Name);
+            }
+        }
     }
 }
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptSymbol.cs b/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptSymbol.cs
index d6fdaeebf..4b34837af 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptSymbol.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptSymbol.cs
@@ -17,6 +17,10 @@ namespace Tango.Scripting.Parsing
         public String ContainingNamespace { get; set; }
         public List<KeyValuePair<String,String>> Parameters { get; set; }
         public String Summary { get; set; }
+        public int Offset { get; set; }
+        public int Length { get; set; }
+        public bool IsUnassigned { get; set; }
+        public ISymbol RealSymbol { get; set; }
 
         public ScriptSymbol()
         {