Scripting refactoring.

9 files changed, 373 insertions, 32 deletions

diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/CachedAssembly.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/CachedAssembly.cs
new file mode 100644
index 000000000..b0178e63e
--- /dev/null
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/CachedAssembly.cs
@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tango.Scripting.Editors.Intellisense;
+
+namespace Tango.Scripting.Editors
+{
+    public class CachedAssembly
+    {
+        public String Name { get; set; }
+        public List<KnownType> KnownTypes { get; set; }
+
+        public CachedAssembly()
+        {
+            KnownTypes = new List<KnownType>();
+        }
+    }
+}
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/UndoStack.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/UndoStack.cs
index f0a759b23..86e1fa33e 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/UndoStack.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Document/UndoStack.cs
@@ -414,7 +414,7 @@ namespace Tango.Scripting.Editors.Document
 		/// </summary>
 		public void ClearAll()
 		{
-			ThrowIfUndoGroupOpen();
+			//ThrowIfUndoGroupOpen();
 			actionCountInUndoGroup = 0;
 			optionalActionCount = 0;
 			if (undostack.Count != 0) {
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Highlighting/Resources/CSharp-Mode.xshd b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Highlighting/Resources/CSharp-Mode.xshd
index 409825b42..6f400c4f5 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Highlighting/Resources/CSharp-Mode.xshd
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Highlighting/Resources/CSharp-Mode.xshd
@@ -194,6 +194,7 @@
 			<Word>enum</Word>
 			<Word>float</Word>
 			<Word>int</Word>
+      <Word>object</Word>
       <Word>string</Word>
 			<Word>long</Word>
 			<Word>sbyte</Word>
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/KnownType.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/KnownType.cs
index 28f9ccb9a..6675eb582 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/KnownType.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/KnownType.cs
@@ -14,8 +14,8 @@ namespace Tango.Scripting.Editors.Intellisense
     public class KnownType
     {
         private bool _initialized;
-        private bool _documentationLoaded;
 
+        public bool DocumentationLoaded { get; set; }
         public Type Type { get; private set; }
         public String Name { get; private set; }
         public String TypeDefinition { get; private set; }
@@ -135,6 +135,7 @@ namespace Tango.Scripting.Editors.Intellisense
                         m.Name = method.Name;
                         m.ReturnType = method.ReturnType;
                         m.ReturnTypeFriendlyName = method.ReturnType.GetFriendlyName();
+                        m.IsStatic = method.IsStatic;
 
                         if (method.IsGenericMethod)
                         {
@@ -148,6 +149,11 @@ namespace Tango.Scripting.Editors.Intellisense
 
                         bool isLinq = method.DeclaringType == typeof(Enumerable);
 
+                        if (isLinq)
+                        {
+                            m.IsStatic = false;
+                        }
+
                         for (int j = 0; j < parameters.Count; j++)
                         {
                             var parameter = parameters[j];
@@ -211,9 +217,9 @@ namespace Tango.Scripting.Editors.Intellisense
 
         public void LoadDocumentation()
         {
-            if (!_documentationLoaded)
+            if (!DocumentationLoaded)
             {
-                _documentationLoaded = true;
+                DocumentationLoaded = true;
 
                 Utils.LoadKnownTypeDocs(this);
             }
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/KnownTypeMethod.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/KnownTypeMethod.cs
index f84e26fe5..4cedad377 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/KnownTypeMethod.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Intellisense/KnownTypeMethod.cs
@@ -8,6 +8,8 @@ namespace Tango.Scripting.Editors.Intellisense
 {
     public class KnownTypeMethod : KnownTypeMember
     {
+        public bool IsStatic { get; set; }
+
         public List<KnownTypeMethodParameter> Parameters { get; set; }
 
         public List<String> TypeArguments { get; set; }
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/ScriptEditor.cs b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/ScriptEditor.cs
index d06862cef..a4493d2c4 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/ScriptEditor.cs
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/ScriptEditor.cs
@@ -1,5 +1,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
@@ -23,7 +24,9 @@ using System.Windows.Navigation;
 using System.Windows.Shapes;
 using System.Windows.Threading;
 using System.Xml;
+using Tango.Core;
 using Tango.Core.Commands;
+using Tango.Scripting.Core;
 using Tango.Scripting.Editors.CodeCompletion;
 using Tango.Scripting.Editors.Document;
 using Tango.Scripting.Editors.Editing;
@@ -52,6 +55,14 @@ namespace Tango.Scripting.Editors
         private List<KnownType> _knownTypes;
         private List<ScriptType> _declaredTypes;
         private bool _isLoadingTypes;
+        private static JsonSerializerSettings _jsonSettings;
+        private static Dictionary<Type, KnownType> _knownTypesCache;
+        private static String KNOWN_TYPES_CACHE_FOLDER;
+        private static List<CachedAssembly> _cachedAssemblies;
+        private static bool _isLoadingCachedAssemblies;
+        private static bool _isCacheAssembliesLoaded;
+
+        public static event EventHandler<TangoProgressChangedEventArgs<int>> AssemblyCacheProgress;
 
         #region Mini Classes
 
@@ -110,13 +121,13 @@ namespace Tango.Scripting.Editors
         /// <summary>
         /// Gets or sets the reference assemblies.
         /// </summary>
-        public ObservableCollection<ReferenceAssembly> ReferenceAssemblies
+        public ObservableCollection<Assembly> ReferenceAssemblies
         {
-            get { return (ObservableCollection<ReferenceAssembly>)GetValue(ReferenceAssembliesProperty); }
+            get { return (ObservableCollection<Assembly>)GetValue(ReferenceAssembliesProperty); }
             set { SetValue(ReferenceAssembliesProperty, value); }
         }
         public static readonly DependencyProperty ReferenceAssembliesProperty =
-            DependencyProperty.Register("ReferenceAssemblies", typeof(ObservableCollection<ReferenceAssembly>), typeof(ScriptEditor), new PropertyMetadata(null));
+            DependencyProperty.Register("ReferenceAssemblies", typeof(ObservableCollection<Assembly>), typeof(ScriptEditor), new PropertyMetadata(null));
 
         public Object CurrentPopupContent
         {
@@ -126,6 +137,21 @@ namespace Tango.Scripting.Editors
         public static readonly DependencyProperty CurrentPopupContentProperty =
             DependencyProperty.Register("CurrentPopupContent", typeof(Object), typeof(ScriptEditor), new PropertyMetadata(null));
 
+        public String Code
+        {
+            get { return (String)GetValue(CodeProperty); }
+            set { SetValue(CodeProperty, value); }
+        }
+        public static readonly DependencyProperty CodeProperty =
+            DependencyProperty.Register("Code", typeof(String), typeof(ScriptEditor), new PropertyMetadata(null, (d, e) => (d as ScriptEditor).OnCodeChanged()));
+
+        public ObservableCollection<IScriptSource> AdditionalScripts
+        {
+            get { return (ObservableCollection<IScriptSource>)GetValue(AdditionalScriptsProperty); }
+            set { SetValue(AdditionalScriptsProperty, value); }
+        }
+        public static readonly DependencyProperty AdditionalScriptsProperty =
+            DependencyProperty.Register("AdditionalScripts", typeof(ObservableCollection<IScriptSource>), typeof(ScriptEditor), new PropertyMetadata(null));
 
         #endregion
 
@@ -137,6 +163,21 @@ namespace Tango.Scripting.Editors
         static ScriptEditor()
         {
             DefaultStyleKeyProperty.OverrideMetadata(typeof(ScriptEditor), new FrameworkPropertyMetadata(typeof(ScriptEditor)));
+
+            if (KNOWN_TYPES_CACHE_FOLDER == null)
+            {
+                KNOWN_TYPES_CACHE_FOLDER = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Twine", "Tango", "Scripting", "Cache");
+                Directory.CreateDirectory(KNOWN_TYPES_CACHE_FOLDER);
+            }
+
+            _jsonSettings = new JsonSerializerSettings()
+            {
+                TypeNameHandling = TypeNameHandling.Auto,
+                PreserveReferencesHandling = PreserveReferencesHandling.All
+            };
+
+            _knownTypesCache = new Dictionary<Type, KnownType>();
+            _cachedAssemblies = new List<CachedAssembly>();
         }
 
         /// <summary>
@@ -148,12 +189,11 @@ namespace Tango.Scripting.Editors
 
             _current_usings = new List<string>();
 
-            ReferenceAssemblies = new ObservableCollection<ReferenceAssembly>();
+            //ReferenceAssemblies = new ObservableCollection<ReferenceAssembly>();
 
-            //Add basic assemblies...
-            ReferenceAssemblies.Add(new ReferenceAssembly(typeof(String))); //mscorelib
-            ReferenceAssemblies.Add(new ReferenceAssembly(typeof(Enumerable))); //System.Core
-            ReferenceAssemblies.Add(new ReferenceAssembly(typeof(Tango.Core.CoreSettings))); //System.Core
+            ////Add basic assemblies...
+            //ReferenceAssemblies.Add(new ReferenceAssembly(typeof(String))); //mscorelib
+            //ReferenceAssemblies.Add(new ReferenceAssembly(typeof(Enumerable))); //System.Core
 
             _knownTypes = new List<KnownType>();
             _parser = new ScriptParser();
@@ -175,6 +215,29 @@ namespace Tango.Scripting.Editors
             completionWindow.AllowsTransparency = true;
             completionWindow.ResizeMode = ResizeMode.NoResize;
             completionWindow.InsertionRequest += CompletionWindow_InsertionRequest;
+
+            TextChanged += ScriptEditor_TextChanged;
+        }
+
+        private bool preventCodeUpdate;
+        private void ScriptEditor_TextChanged(object sender, EventArgs e)
+        {
+            if (!preventCodeUpdate)
+            {
+                preventCodeUpdate = true;
+                Code = Text;
+                preventCodeUpdate = false;
+            }
+        }
+
+        private void OnCodeChanged()
+        {
+            if (!preventCodeUpdate)
+            {
+                preventCodeUpdate = true;
+                Text = Code;
+                preventCodeUpdate = false;
+            }
         }
 
         #endregion
@@ -370,16 +433,17 @@ namespace Tango.Scripting.Editors
                 {
                     var knownType = GetCurrentKnownType();
 
+                    IList<ICompletionData> data = new List<ICompletionData>();
+
                     if (knownType != null)
                     {
                         completionWindow.HideCompletion();
-                        IList<ICompletionData> data = new List<ICompletionData>();
 
                         if (!knownType.Type.IsEnum)
                         {
                             var typeMembers = knownType.Members.ToList();
 
-                            foreach (var methodGroup in typeMembers.OfType<KnownTypeMethod>().GroupBy(x => x.NameWithTypeArguments))
+                            foreach (var methodGroup in typeMembers.OfType<KnownTypeMethod>().Where(x => !x.IsStatic).GroupBy(x => x.NameWithTypeArguments))
                             {
                                 var method = methodGroup.First();
 
@@ -432,7 +496,6 @@ namespace Tango.Scripting.Editors
                         if (declaredType != null)
                         {
                             completionWindow.HideCompletion();
-                            IList<ICompletionData> data = new List<ICompletionData>();
 
                             var typeMembers = declaredType.Symbols.ToList();
 
@@ -491,6 +554,34 @@ namespace Tango.Scripting.Editors
 
                             ShowCompletionWindow(data, GetCurrentWord());
                         }
+                        else
+                        {
+                            //Maybe static ...
+                            var typeText = GetPreviousWord();
+                            knownType = _knownTypes.FirstOrDefault(x => x.FriendlyName == typeText);
+
+                            if (knownType != null)
+                            {
+                                var typeMembers = knownType.Members.ToList();
+
+                                foreach (var methodGroup in typeMembers.OfType<KnownTypeMethod>().Where(x => x.IsStatic).GroupBy(x => x.NameWithTypeArguments))
+                                {
+                                    var method = methodGroup.First();
+
+                                    data.Add(new MethodCompletionItem()
+                                    {
+                                        Class = knownType.FriendlyName,
+                                        Name = method.NameWithTypeArguments,
+                                        ReturnType = method.ReturnTypeFriendlyName,
+                                        Description = method.Summary,
+                                        Parameters = method.Parameters,
+                                        Overloads = methodGroup.Count() - 1,
+                                    });
+                                }
+
+                                ShowCompletionWindow(data.OrderBy(x => x.Text).ToList(), GetCurrentWord());
+                            }
+                        }
                     }
                 }
                 else if (e.Text == "(" || e.Text == ",")
@@ -534,6 +625,18 @@ namespace Tango.Scripting.Editors
                                 return;
                             }
                         }
+
+                        var staticMethodSession = GetStaticMethodSession();
+
+                        if (staticMethodSession != null)
+                        {
+                            var content = CreateMethodSessionPopupContent(staticMethodSession);
+                            if (content.Methods.Count > 0)
+                            {
+                                ShowPopup(content);
+                                return;
+                            }
+                        }
                     }
                     catch (Exception ex)
                     {
@@ -552,12 +655,12 @@ namespace Tango.Scripting.Editors
 
                     foreach (var asm in ReferenceAssemblies)
                     {
-                        foreach (var ns in asm.Assembly.GetTypes().Select(x => x.Namespace).Distinct().Where(x => x != null))
+                        foreach (var ns in asm.GetTypes().Select(x => x.Namespace).Distinct().Where(x => x != null))
                         {
                             data.Add(new NamespaceCompletionItem()
                             {
                                 Name = ns,
-                                Assembly = asm.Assembly.GetName().Name,
+                                Assembly = asm.GetName().Name,
                             });
                         }
                     }
@@ -1147,33 +1250,114 @@ namespace Tango.Scripting.Editors
             return popup;
         }
 
-        private void InvalidateHighlighting()
+        public static void LoadCachedAssemblies(List<Assembly> assemblies)
+        {
+            if (_isLoadingCachedAssemblies) return;
+
+            _isLoadingCachedAssemblies = true;
+
+            if (!_isCacheAssembliesLoaded)
+            {
+                foreach (var file in System.IO.Directory.GetFiles(KNOWN_TYPES_CACHE_FOLDER))
+                {
+                    try
+                    {
+                        AssemblyCacheProgress?.Invoke(null, new TangoProgressChangedEventArgs<int>()
+                        {
+                            Progress = new TangoProgress<int>()
+                            {
+                                IsIndeterminate = true,
+                                Maximum = 100,
+                                Message = $"Loading metadata cache for '{System.IO.Path.GetFileName(file)}'..."
+                            }
+                        });
+
+                        var cachedAssembly = JsonConvert.DeserializeObject<CachedAssembly>(System.IO.File.ReadAllText(file), _jsonSettings);
+
+                        foreach (var knownType in cachedAssembly.KnownTypes)
+                        {
+                            _knownTypesCache.Add(knownType.Type, knownType);
+                        }
+
+                        _cachedAssemblies.Add(cachedAssembly);
+                    }
+                    catch { }
+                }
+
+                _isCacheAssembliesLoaded = true;
+            }
+
+            foreach (var asm in assemblies)
+            {
+                if (!_cachedAssemblies.Exists(x => x.Name == asm.FullName))
+                {
+                    String asmFileName = System.IO.Path.GetFileName(asm.Location);
+
+                    CachedAssembly cachedAssembly = new CachedAssembly();
+                    cachedAssembly.Name = asm.FullName;
+                    _cachedAssemblies.Add(cachedAssembly);
+
+                    var types = asm.GetTypes().Where(x => x.IsVisible && x.IsPublic && !x.IsPrimitive).ToList();
+
+                    int i = 0;
+
+                    foreach (var type in types)
+                    {
+                        AssemblyCacheProgress?.Invoke(null, new TangoProgressChangedEventArgs<int>()
+                        {
+                            Progress = new TangoProgress<int>()
+                            {
+                                IsIndeterminate = false,
+                                Maximum = types.Count,
+                                Value = i++,
+                                Message = $"Caching metadata for '{asmFileName}'..."
+                            }
+                        });
+
+                        KnownType knownType = new KnownType(type);
+                        _knownTypesCache.Add(type, knownType);
+                        cachedAssembly.KnownTypes.Add(knownType);
+                        knownType.LoadDocumentation();
+                    }
+
+                    String cachedAssemblyFile = System.IO.Path.Combine(KNOWN_TYPES_CACHE_FOLDER, asmFileName);
+                    File.WriteAllText(cachedAssemblyFile, JsonConvert.SerializeObject(cachedAssembly, _jsonSettings));
+                }
+            }
+
+            _isLoadingCachedAssemblies = false;
+        }
+
+        private void InvalidateHighlighting(bool loadKnownTypes = true)
         {
             if (!_isLoadingTypes)
             {
                 _isLoadingTypes = true;
-                _knownTypes.Clear();
 
                 var assemblies = ReferenceAssemblies.ToList();
                 var usings = _current_usings.ToList();
 
                 Thread t = new Thread(() =>
                 {
-                    foreach (var asm in assemblies.Select(x => x.Assembly))
+                    LoadCachedAssemblies(assemblies);
+
+                    if (loadKnownTypes)
                     {
-                        Parallel.ForEach(asm.GetTypes().Where(x => x.IsVisible && x.IsPublic && !x.IsPrimitive), (type) =>
+                        _knownTypes.Clear();
+
+                        foreach (var asm in assemblies)
                         {
-                            if (usings.Exists(x => type.Namespace == x))
+                            foreach (var knownType in _knownTypesCache.ToList().Select(x => x.Value).ToList())
                             {
-                                lock (_knownTypes)
+                                if (usings.Exists(x => knownType.Type.Namespace == x))
                                 {
-                                    if (!_knownTypes.Exists(x => x.Type.FullName == type.FullName))
+                                    lock (_knownTypes)
                                     {
-                                        _knownTypes.Add(new KnownType(type));
+                                        _knownTypes.Add(knownType);
                                     }
                                 }
                             }
-                        });
+                        }
                     }
 
                     if (_knownTypes.Count > 0 || _declaredTypes.Count > 0)
@@ -1246,10 +1430,10 @@ namespace Tango.Scripting.Editors
                         }));
 
 
-                        foreach (var knownType in _knownTypes)
-                        {
-                            knownType.LoadDocumentation();
-                        }
+                        //foreach (var knownType in _knownTypes)
+                        //{
+                        //    knownType.LoadDocumentation();
+                        //}
                     }
 
                     _isLoadingTypes = false;
@@ -1263,10 +1447,19 @@ namespace Tango.Scripting.Editors
         {
             var declaredTypes = _parser.GetDeclaredTypes(Text);
 
+            if (AdditionalScripts != null)
+            {
+                foreach (var script in AdditionalScripts)
+                {
+                    declaredTypes.AddRange(_parser.GetDeclaredTypes(script.Code));
+                }
+            }
+
+
             if (declaredTypes.Exists(x => !_declaredTypes.Exists(y => y.Name == x.Name)) || _declaredTypes.Exists(x => !declaredTypes.Exists(y => y.Name == x.Name)))
             {
                 _declaredTypes = declaredTypes;
-                InvalidateHighlighting();
+                InvalidateHighlighting(false);
             }
 
             _declaredTypes = declaredTypes;
@@ -1452,6 +1645,48 @@ namespace Tango.Scripting.Editors
 
                 }
             }
+            else
+            {
+                var expression2 = _parser.GetCurrentConstructionExpressionAlt(GetCurrentLineText());
+
+                if (expression2 != null && expression2.Identifier != null)
+                {
+                    ConstructionSession session = new ConstructionSession();
+
+                    var line = GetCurrentLine();
+                    int parameterIndex = 0;
+                    for (int i = CaretOffset; i > line.Offset; i--)
+                    {
+                        String c = Document.GetText(i, 1);
+
+                        if (c == "(")
+                        {
+                            KnownType type = null;
+
+                            if (expression2.Identifier != null)
+                            {
+                                var typeName = expression2.Identifier.ToString();
+                                type = _knownTypes.FirstOrDefault(x => x.Type.Name == typeName);
+
+                                if (type != null)
+                                {
+                                    session.Type = type;
+                                    session.ParameterIndex = parameterIndex;
+                                    return session;
+                                }
+                                else
+                                {
+                                    return null;
+                                }
+                            }
+                        }
+                        else if (c == ",")
+                        {
+                            parameterIndex++;
+                        }
+                    }
+                }
+            }
 
             return null;
         }
@@ -1515,6 +1750,65 @@ namespace Tango.Scripting.Editors
             return null;
         }
 
+        private MethodSession GetStaticMethodSession()
+        {
+            var words = GetCurrentLineText().Split(' ');
+
+            if (words.Count() > 0 && (words.First() == "private" || words.First() == "public" || words.First() == "void"))
+            {
+                return null;
+            }
+
+            var expression = words.LastOrDefault();
+
+            if (expression != null)
+            {
+                int parameterIndex = expression.Count(x => x == ',');
+                expression = new string(expression.TakeWhile(x => x != '(').ToArray());
+
+                var tree = expression.Split('.').Select(x => x.Remove(@"\n|\r|\s|\t|\(|\)|\[|\]|<.*>")).ToList();
+                var variableName = tree.FirstOrDefault();
+
+                if (variableName != null && tree.Count > 1)
+                {
+                    tree.RemoveAt(0);
+                    var variables = _parser.GetContextSymbols(Document.Text, CaretOffset);
+                    var variable = variableName;
+
+                    if (variable != null)
+                    {
+                        var knownType = _knownTypes.FirstOrDefault(x => x.FriendlyName == Regex.Replace(variable, "<.+>", "<T>"));
+
+                        if (knownType != null)
+                        {
+                            while (tree.Count > 1)
+                            {
+                                var memberName = tree.First();
+                                tree.RemoveAt(0);
+                                var member = knownType.Members.FirstOrDefault(x => x.Name == memberName);
+
+                                if (member == null)
+                                {
+                                    return null;
+                                }
+
+                                knownType = _knownTypes.FirstOrDefault(x => x.Type.Namespace + "." + x.Type.Name == member.ReturnType.Namespace + "." + member.ReturnType.Name);
+                            }
+
+                            return new MethodSession()
+                            {
+                                Type = knownType,
+                                MethodName = tree.Last(),
+                                ParameterIndex = parameterIndex,
+                            };
+                        }
+                    }
+                }
+            }
+
+            return null;
+        }
+
         private DeclaredMethodSession GetDeclaredMethodSession()
         {
             var words = GetCurrentLineText().Split(' ');
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Tango.Scripting.Editors.csproj b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Tango.Scripting.Editors.csproj
index ce7c361e3..d6c89f0a4 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Tango.Scripting.Editors.csproj
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/Tango.Scripting.Editors.csproj
@@ -77,6 +77,9 @@
     <Reference Include="Microsoft.CodeAnalysis.CSharp, Version=2.4.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Microsoft.CodeAnalysis.CSharp.2.4.0\lib\netstandard1.3\Microsoft.CodeAnalysis.CSharp.dll</HintPath>
     </Reference>
+    <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="PresentationCore">
       <RequiredTargetFramework>3.0</RequiredTargetFramework>
     </Reference>
@@ -177,6 +180,7 @@
       <Link>GlobalVersionInfo.cs</Link>
     </Compile>
     <Compile Include="AvalonEditCommands.cs" />
+    <Compile Include="CachedAssembly.cs" />
     <Compile Include="CodeCompletion\CompletionListBox.cs" />
     <Compile Include="CodeCompletion\CompletionListBoxItem.cs" />
     <Compile Include="CodeCompletion\CompletionWindowBase.cs" />
@@ -579,6 +583,10 @@
       <Project>{a34ee0f0-649d-41c8-8489-b6f1cc6924ee}</Project>
       <Name>Tango.Core</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Tango.Scripting.Core\Tango.Scripting.Core.csproj">
+      <Project>{5812E1C6-ABAA-4066-94AC-971C27B4F46A}</Project>
+      <Name>Tango.Scripting.Core</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Tango.Scripting\Tango.Scripting.csproj">
       <Project>{1e938fd2-c669-4738-98c9-77f96ce4d451}</Project>
       <Name>Tango.Scripting</Name>
@@ -628,7 +636,7 @@
   </ItemGroup>
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties BuildVersion_UseGlobalSettings="True" BuildVersion_AssemblyInfoFilename="Properties\AssemblyInfo.cs" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_BuildVersioningStyle="None.None.Increment.TimeStamp" BuildVersion_StartDate="2000/1/1" />
+      <UserProperties BuildVersion_StartDate="2000/1/1" BuildVersion_BuildVersioningStyle="None.None.Increment.TimeStamp" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_AssemblyInfoFilename="Properties\AssemblyInfo.cs" BuildVersion_UseGlobalSettings="True" />
     </VisualStudio>
   </ProjectExtensions>
 </Project>
\ No newline at end of file
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/app.config b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/app.config
index d3a17b4de..16d75cf59 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/app.config
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/app.config
@@ -77,6 +77,14 @@
  
           </dependentAssembly>
  
+          <dependentAssembly>
+ 
+              <assemblyIdentity name="Microsoft.IdentityModel.Clients.ActiveDirectory" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+ 
+              <bindingRedirect oldVersion="0.0.0.0-5.0.5.0" newVersion="5.0.5.0" />
+ 
+          </dependentAssembly>
+ 
       </assemblyBinding>
  
   </runtime>
diff --git a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/packages.config b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/packages.config
index 00eef19db..a0f62a1d4 100644
--- a/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/packages.config
+++ b/Software/Visual_Studio/Scripting/Tango.Scripting.Editors/packages.config
@@ -4,6 +4,7 @@
   <package id="Microsoft.CodeAnalysis.Analyzers" version="1.1.0" targetFramework="net461" />
   <package id="Microsoft.CodeAnalysis.Common" version="2.4.0" targetFramework="net461" />
   <package id="Microsoft.CodeAnalysis.CSharp" version="2.4.0" targetFramework="net461" />
+  <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net461" />
   <package id="System.AppContext" version="4.3.0" targetFramework="net461" />
   <package id="System.Collections" version="4.3.0" targetFramework="net461" />
   <package id="System.Collections.Concurrent" version="4.3.0" targetFramework="net461" />