FSE work + fixed issue with personal access token on MS and PPC.

3 files changed, 107 insertions, 18 deletions

diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Basic/Project.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Basic/Project.cs
index 85caf4706..14a9d94da 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Basic/Project.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Basic/Project.cs
@@ -73,9 +73,9 @@ namespace Tango.Scripting.Basic
         {
             ReferenceAssembliesLoaded.Clear();
 
-            foreach (var type in ReferenceAssemblies)
+            foreach (var asm in ReferenceAssemblies)
             {
-                ReferenceAssembliesLoaded.Add(type.FromType.Assembly);
+                ReferenceAssembliesLoaded.Add(Assembly.LoadFrom(asm.File));
             }
         }
 
@@ -85,10 +85,10 @@ namespace Tango.Scripting.Basic
 
             p.Name = name;
 
-            p.ReferenceAssemblies.Add(new ReferenceAssembly() { FromType = typeof(String) });
-            p.ReferenceAssemblies.Add(new ReferenceAssembly() { FromType = typeof(Enumerable) });
-            p.ReferenceAssemblies.Add(new ReferenceAssembly() { FromType = typeof(Form) });
-            p.ReferenceAssemblies.Add(new ReferenceAssembly() { FromType = typeof(Project<T>) });
+            p.ReferenceAssemblies.Add(ReferenceAssembly.FromType(typeof(String)));
+            p.ReferenceAssemblies.Add(ReferenceAssembly.FromType(typeof(Enumerable)));
+            p.ReferenceAssemblies.Add(ReferenceAssembly.FromType(typeof(Form)));
+            p.ReferenceAssemblies.Add(ReferenceAssembly.FromType(typeof(Project<T>)));
             return p;
         }
 
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Basic/ReferenceAssembly.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Basic/ReferenceAssembly.cs
index be66e026b..4b04270c1 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Basic/ReferenceAssembly.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Basic/ReferenceAssembly.cs
@@ -1,5 +1,7 @@
-using System;
+using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -8,11 +10,25 @@ namespace Tango.Scripting.Basic
 {
     public class ReferenceAssembly
     {
-        public Type FromType { get; set; }
+        public String File { get; set; }
 
+        [JsonIgnore]
         public String Name
         {
-            get { return FromType.Assembly.GetName().Name; }
+            get { return Path.GetFileNameWithoutExtension(File); }
+        }
+
+        public static ReferenceAssembly FromType(Type type)
+        {
+            ReferenceAssembly reference = new ReferenceAssembly();
+            var assembly = type.Assembly;
+            reference.File = assembly.Location;
+            return reference;
+        }
+
+        public static ReferenceAssembly FromFile(String file)
+        {
+            return new ReferenceAssembly() { File = file };
         }
     }
 }
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptParser.cs b/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptParser.cs
index 7accdbb83..e9cb8fc4c 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptParser.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting/Parsing/ScriptParser.cs
@@ -131,16 +131,32 @@ 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.Accessibility = symbol.DeclaredAccessibility;
+                        varSymbol.ContainingNamespace = ReplaceFakeScript(symbol.ContainingNamespace?.Name);
+                        varSymbol.Summary = GetSymbolDocumentation(symbol);
+                        vars.Add(varSymbol);
+
+                        if (type == "?")
                         {
-                            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),
-                        });
+                            try
+                            {
+                                var variables = GetScriptVariables(code);
+                                var variable = variables.FirstOrDefault(x => x.Name == symbol.Name);
+
+                                if (variable != null)
+                                {
+                                    varSymbol.Type = variable.Type;
+                                }
+                            }
+                            catch { }
+                        }
                     }
                 }
             }
@@ -392,5 +408,62 @@ 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, 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, SyntaxNode node)
+        {
+            foreach (var item in node.DescendantNodes(x => true))
+            {
+                if (item.GetType() == typeof(VariableDeclaratorSyntax))
+                {
+                    variables.Add(item as VariableDeclaratorSyntax);
+                }
+                else
+                {
+                    FillVariables(variables, 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);
+            }
+        }
     }
 }