Pseudo implementation of local variables intellisense

Hexer10 · Hexer10 · commit 556be2de2db6 · 2020-03-31T13:33:53.000+02:00
diff --git a/SourcepawnCondenser/SourcepawnCondenser/Condenser.cs b/SourcepawnCondenser/SourcepawnCondenser/Condenser.cs
@@ -9,9 +9,9 @@ public partial class Condenser
     {
         private readonly SMDefinition def;
 
-        private readonly string FileName = string.Empty;
+        private readonly string FileName;
         private readonly int length;
-        private readonly string source = string.Empty;
+        private readonly string source;
         private readonly Token[] t;
         private int position;
 
@@ -141,6 +141,8 @@ public SMDefinition Condense()
                             position = newIndex + 1;
                             continue;
                         }
+                        
+                        // If Variable is not found try function
                         newIndex = ConsumeSMFunction();
                         if (newIndex != -1)
                         {
diff --git a/SourcepawnCondenser/SourcepawnCondenser/CondenserFunctions/SMFunctionConsumer.cs b/SourcepawnCondenser/SourcepawnCondenser/CondenserFunctions/SMFunctionConsumer.cs
@@ -197,6 +197,7 @@ private int ConsumeSMFunction()
                     {
                         FunctionKind = kind,
                         Index = t[startPosition].Index,
+                        EndPos = parameterDeclIndexEnd,
                         File = FileName,
                         Length = parameterDeclIndexEnd - t[startPosition].Index + 1,
                         Name = functionName,
@@ -228,6 +229,7 @@ private int ConsumeSMFunction()
                                 localVars = LocalVars.ConsumeSMVariableLocal(segment.ToArray(), FileName);
                                 def.Functions.Add(new SMFunction
                                 {
+                                    EndPos = t[nextOpenBraceTokenIndex + (i - nextOpenBraceTokenIndex) + 1].Index,
                                     FunctionKind = kind,
                                     Index = t[startPosition].Index,
                                     File = FileName,
@@ -248,6 +250,7 @@ private int ConsumeSMFunction()
 
             def.Functions.Add(new SMFunction
             {
+                EndPos = parameterDeclIndexEnd,
                 FunctionKind = kind,
                 Index = t[startPosition].Index,
                 File = FileName,
diff --git a/SourcepawnCondenser/SourcepawnCondenser/SMDefinition/SMDefinition.cs b/SourcepawnCondenser/SourcepawnCondenser/SMDefinition/SMDefinition.cs
@@ -39,8 +39,7 @@ public string[]
         public List<SMTypedef> Typedefs = new List<SMTypedef>();
         public string[] TypeStrings = new string[0];
         public List<SMVariable> Variables = new List<SMVariable>();
-        public string[] VariableStrings = new string[0];
-        
+
         public void Sort()
         {
             try
@@ -90,7 +89,7 @@ public void AppendFiles(IEnumerable<string> paths)
             ProduceStringArrays();
         }
 
-        private void ProduceStringArrays()
+        private void ProduceStringArrays(int caret = -1, string text = "")
         {
             FunctionStrings = new string[Functions.Count];
             for (var i = 0; i < Functions.Count; ++i) FunctionStrings[i] = Functions[i].Name;
@@ -100,7 +99,6 @@ private void ProduceStringArrays()
             var enumStructNames = new List<string>();
             var structMethodNames = new List<string>();
             var structFieldNames = new List<string>();
-            var varNames = new List<string>();
 
             foreach (var mm in Methodmaps)
             {
@@ -116,22 +114,29 @@ private void ProduceStringArrays()
                 structFieldNames.AddRange(sm.Fields.Select(f => f.Name));
             }
 
-            foreach (var v in Variables) varNames.Add(v.Name);
-
             MethodsStrings = methodNames.ToArray();
             FieldStrings = fieldNames.ToArray();
             StructFieldStrings = structFieldNames.ToArray();
             StructMethodStrings = structMethodNames.ToArray();
             MethodmapsStrings = methodmapNames.ToArray();
             EnumStructStrings = enumStructNames.ToArray();
-            VariableStrings = varNames.ToArray();
 
             var constantNames = Constants.Select(i => i.Name).ToList();
             foreach (var e in Enums) constantNames.AddRange(e.Entries);
 
             constantNames.AddRange(Defines.Select(i => i.Name));
             constantNames.AddRange(Variables.Select(v => v.Name));
 
+            if (caret != -1)
+            {
+                var currentFunc = Functions.FirstOrDefault(e => e.Index < caret && caret <= e.EndPos && e.File.EndsWith(".sp"));
+                if (currentFunc != null)
+                {
+                    
+                    constantNames.AddRange(currentFunc.FuncVariables.Select(v => v.Name));
+                }
+            }
+
             constantNames.Sort(string.Compare);
             ConstantsStrings = constantNames.ToArray();
             var typeNames = new List<string>
@@ -171,7 +176,7 @@ public ISNode[] ProduceISNodes()
             nodes.AddRange(ISNode.ConvertFromStringArray(FieldStrings, false, "• "));
             nodes.AddRange(ISNode.ConvertFromStringArray(StructFieldStrings, false, "• "));
 
-            nodes.AddRange(ISNode.ConvertFromStringArray(VariableStrings, false, "v "));
+            // nodes.AddRange(ISNode.ConvertFromStringArray(VariableStrings, false, "v "));
 
             nodes = nodes.Distinct(new ISNodeEqualityComparer()).ToList();
             nodes.Sort((a, b) => string.CompareOrdinal(a.EntryName, b.EntryName));
@@ -198,30 +203,24 @@ public void MergeDefinitions(SMDefinition def)
             }
         }
 
-        public SMDefinition ProduceTemporaryExpandedDefinition(SMDefinition[] definitions)
+        public SMDefinition ProduceTemporaryExpandedDefinition(SMDefinition[] definitions, int caret, string text)
         {
             var def = new SMDefinition();
-            try
-            {
                 def.MergeDefinitions(this);
-                for (var i = 0; i < definitions.Length; ++i)
-                    if (definitions[i] != null)
-                        def.MergeDefinitions(definitions[i]);
-                def.Sort();
-                def.ProduceStringArrays();
-            }
-            catch (Exception)
-            {
-            }
+                foreach (var definition in definitions)
+                    if (definition != null)
+                        def.MergeDefinitions(definition);
 
+                def.Sort();
+                def.ProduceStringArrays(caret, text);
             return def;
         }
 
         private class SMFunctionComparer : IEqualityComparer<SMFunction>
         {
             public bool Equals(SMFunction left, SMFunction right)
             {
-                return left.Name == right.Name;
+                return left?.Name == right?.Name;
             }
 
             public int GetHashCode(SMFunction sm)
@@ -234,7 +233,7 @@ private class SMEnumComparer : IEqualityComparer<SMEnum>
         {
             public bool Equals(SMEnum left, SMEnum right)
             {
-                return left.Name == right.Name;
+                return left?.Name == right?.Name;
             }
 
             public int GetHashCode(SMEnum sm)
@@ -247,7 +246,7 @@ private class SMStructComparer : IEqualityComparer<SMStruct>
         {
             public bool Equals(SMStruct left, SMStruct right)
             {
-                return left.Name == right.Name;
+                return left?.Name == right?.Name;
             }
 
             public int GetHashCode(SMStruct sm)
@@ -260,7 +259,7 @@ private class SMDefineComparer : IEqualityComparer<SMDefine>
         {
             public bool Equals(SMDefine left, SMDefine right)
             {
-                return left.Name == right.Name;
+                return left?.Name == right?.Name;
             }
 
             public int GetHashCode(SMDefine sm)
@@ -273,7 +272,7 @@ private class SMConstantComparer : IEqualityComparer<SMConstant>
         {
             public bool Equals(SMConstant left, SMConstant right)
             {
-                return left.Name == right.Name;
+                return left?.Name == right?.Name;
             }
 
             public int GetHashCode(SMConstant sm)
@@ -286,7 +285,7 @@ private class SMMethodmapsComparer : IEqualityComparer<SMMethodmap>
         {
             public bool Equals(SMMethodmap left, SMMethodmap right)
             {
-                return left.Name == right.Name;
+                return left?.Name == right?.Name;
             }
 
             public int GetHashCode(SMMethodmap sm)
@@ -307,7 +306,7 @@ public class ISNodeEqualityComparer : IEqualityComparer<ISNode>
         {
             public bool Equals(ISNode nodeA, ISNode nodeB)
             {
-                return nodeA.EntryName == nodeB.EntryName;
+                return nodeA?.EntryName == nodeB?.EntryName;
             }
 
             public int GetHashCode(ISNode node)
diff --git a/SourcepawnCondenser/SourcepawnCondenser/SMDefinition/SMFunction.cs b/SourcepawnCondenser/SourcepawnCondenser/SMDefinition/SMFunction.cs
@@ -6,6 +6,7 @@ public class SMFunction
 	{
 		public int Index = -1;
 		public int Length = 0;
+		public int EndPos = -1;
 		public string File = string.Empty;
 
 		public string Name = string.Empty;
@@ -15,7 +16,6 @@ public class SMFunction
 		public string[] Parameters = new string[0];
 		public SMFunctionKind FunctionKind = SMFunctionKind.Unknown;
 		public List<SMVariable> FuncVariables = new List<SMVariable>();
-		public string Body = string.Empty;
 	}
 
 	public enum SMFunctionKind
diff --git a/UI/MainWindowBackgroundParser.cs b/UI/MainWindowBackgroundParser.cs
@@ -43,12 +43,14 @@ private void ParseDistributorTimer_Elapsed(object sender, ElapsedEventArgs args)
             if (ee == null || ce == null) return;
 
             Debug.Assert(ee != null, nameof(ee) + " != null");
+            // ReSharper disable once PossibleNullReferenceException
             foreach (var e in ee)
                 if (e.LastSMDefUpdateUID < currentSMDefUID) //wants an update of the SMDefinition
                 {
                     if (e == ce)
                     {
                         Debug.Assert(ce != null, nameof(ce) + " != null");
+                        // ReSharper disable once PossibleNullReferenceException
                         if (ce.ISAC_Open) continue;
                     }
 
@@ -63,8 +65,11 @@ private void BackgroundParser_Worker()
             while (true)
             while (Program.OptionsObject.Program_DynamicISAC)
             {
-                Thread.Sleep(5000);
+                Thread.Sleep(1000);
                 var ee = GetAllEditorElements();
+                var caret = -1;
+                var text = string.Empty;
+                
                 if (ee != null)
                 {
                     var definitions = new SMDefinition[ee.Length];
@@ -81,15 +86,19 @@ private void BackgroundParser_Worker()
                             Dispatcher.Invoke(() =>
                             {
                                 if (ee[i1].IsLoaded)
+                                {
+                                    caret = ee[i1].editor.CaretOffset;
+                                    text = ee[i1].editor.Text;
                                     definitions[i1] =
                                         new Condenser(File.ReadAllText(fInfo.FullName), fInfo.Name)
                                             .Condense();
+                                }
                             });
                         }
                     }
 
                     currentSMDef = Program.Configs[Program.SelectedConfig].GetSMDef()
-                        .ProduceTemporaryExpandedDefinition(definitions);
+                        .ProduceTemporaryExpandedDefinition(definitions, caret, text);
                     currentSMFunctions = currentSMDef.Functions.ToArray();
                     currentACNodes = currentSMDef.ProduceACNodes();
                     currentISNodes = currentSMDef.ProduceISNodes();

Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,9 @@ public partial class Condenser`
`9`	`9`	`{`
`10`	`10`	`private readonly SMDefinition def;`
`11`	`11`
`12`		`- private readonly string FileName = string.Empty;`
	`12`	`+ private readonly string FileName;`
`13`	`13`	`private readonly int length;`
`14`		`- private readonly string source = string.Empty;`
	`14`	`+ private readonly string source;`
`15`	`15`	`private readonly Token[] t;`
`16`	`16`	`private int position;`
`17`	`17`
`@@ -141,6 +141,8 @@ public SMDefinition Condense()`
`141`	`141`	`position = newIndex + 1;`
`142`	`142`	`continue;`
`143`	`143`	`}`
	`144`	`+`
	`145`	`+ // If Variable is not found try function`
`144`	`146`	`newIndex = ConsumeSMFunction();`
`145`	`147`	`if (newIndex != -1)`
`146`	`148`	`{`
Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,7 @@ public string[]`
`39`	`39`	`public List<SMTypedef> Typedefs = new List<SMTypedef>();`
`40`	`40`	`public string[] TypeStrings = new string[0];`
`41`	`41`	`public List<SMVariable> Variables = new List<SMVariable>();`
`42`		`- public string[] VariableStrings = new string[0];`
`43`		`-`
	`42`	`+`
`44`	`43`	`public void Sort()`
`45`	`44`	`{`
`46`	`45`	`try`
`@@ -90,7 +89,7 @@ public void AppendFiles(IEnumerable<string> paths)`
`90`	`89`	`ProduceStringArrays();`
`91`	`90`	`}`
`92`	`91`
`93`		`- private void ProduceStringArrays()`
	`92`	`+ private void ProduceStringArrays(int caret = -1, string text = "")`
`94`	`93`	`{`
`95`	`94`	`FunctionStrings = new string[Functions.Count];`
`96`	`95`	`for (var i = 0; i < Functions.Count; ++i) FunctionStrings[i] = Functions[i].Name;`
`@@ -100,7 +99,6 @@ private void ProduceStringArrays()`
`100`	`99`	`var enumStructNames = new List<string>();`
`101`	`100`	`var structMethodNames = new List<string>();`
`102`	`101`	`var structFieldNames = new List<string>();`
`103`		`- var varNames = new List<string>();`
`104`	`102`
`105`	`103`	`foreach (var mm in Methodmaps)`
`106`	`104`	`{`
`@@ -116,22 +114,29 @@ private void ProduceStringArrays()`
`116`	`114`	`structFieldNames.AddRange(sm.Fields.Select(f => f.Name));`
`117`	`115`	`}`
`118`	`116`
`119`		`- foreach (var v in Variables) varNames.Add(v.Name);`
`120`		`-`
`121`	`117`	`MethodsStrings = methodNames.ToArray();`
`122`	`118`	`FieldStrings = fieldNames.ToArray();`
`123`	`119`	`StructFieldStrings = structFieldNames.ToArray();`
`124`	`120`	`StructMethodStrings = structMethodNames.ToArray();`
`125`	`121`	`MethodmapsStrings = methodmapNames.ToArray();`
`126`	`122`	`EnumStructStrings = enumStructNames.ToArray();`
`127`		`- VariableStrings = varNames.ToArray();`
`128`	`123`
`129`	`124`	`var constantNames = Constants.Select(i => i.Name).ToList();`
`130`	`125`	`foreach (var e in Enums) constantNames.AddRange(e.Entries);`
`131`	`126`
`132`	`127`	`constantNames.AddRange(Defines.Select(i => i.Name));`
`133`	`128`	`constantNames.AddRange(Variables.Select(v => v.Name));`
`134`	`129`
	`130`	`+ if (caret != -1)`
	`131`	`+ {`
	`132`	`+ var currentFunc = Functions.FirstOrDefault(e => e.Index < caret && caret <= e.EndPos && e.File.EndsWith(".sp"));`
	`133`	`+ if (currentFunc != null)`
	`134`	`+ {`
	`135`	`+`
	`136`	`+ constantNames.AddRange(currentFunc.FuncVariables.Select(v => v.Name));`
	`137`	`+ }`
	`138`	`+ }`
	`139`	`+`
`135`	`140`	`constantNames.Sort(string.Compare);`
`136`	`141`	`ConstantsStrings = constantNames.ToArray();`
`137`	`142`	`var typeNames = new List<string>`
`@@ -171,7 +176,7 @@ public ISNode[] ProduceISNodes()`
`171`	`176`	`nodes.AddRange(ISNode.ConvertFromStringArray(FieldStrings, false, "• "));`
`172`	`177`	`nodes.AddRange(ISNode.ConvertFromStringArray(StructFieldStrings, false, "• "));`
`173`	`178`
`174`		`- nodes.AddRange(ISNode.ConvertFromStringArray(VariableStrings, false, "v "));`
	`179`	`+ // nodes.AddRange(ISNode.ConvertFromStringArray(VariableStrings, false, "v "));`
`175`	`180`
`176`	`181`	`nodes = nodes.Distinct(new ISNodeEqualityComparer()).ToList();`
`177`	`182`	`nodes.Sort((a, b) => string.CompareOrdinal(a.EntryName, b.EntryName));`
`@@ -198,30 +203,24 @@ public void MergeDefinitions(SMDefinition def)`
`198`	`203`	`}`
`199`	`204`	`}`
`200`	`205`
`201`		`- public SMDefinition ProduceTemporaryExpandedDefinition(SMDefinition[] definitions)`
	`206`	`+ public SMDefinition ProduceTemporaryExpandedDefinition(SMDefinition[] definitions, int caret, string text)`
`202`	`207`	`{`
`203`	`208`	`var def = new SMDefinition();`
`204`		`- try`
`205`		`- {`
`206`	`209`	`def.MergeDefinitions(this);`
`207`		`- for (var i = 0; i < definitions.Length; ++i)`
`208`		`- if (definitions[i] != null)`
`209`		`- def.MergeDefinitions(definitions[i]);`
`210`		`- def.Sort();`
`211`		`- def.ProduceStringArrays();`
`212`		`- }`
`213`		`- catch (Exception)`
`214`		`- {`
`215`		`- }`
	`210`	`+ foreach (var definition in definitions)`
	`211`	`+ if (definition != null)`
	`212`	`+ def.MergeDefinitions(definition);`
`216`	`213`
	`214`	`+ def.Sort();`
	`215`	`+ def.ProduceStringArrays(caret, text);`
`217`	`216`	`return def;`
`218`	`217`	`}`
`219`	`218`
`220`	`219`	`private class SMFunctionComparer : IEqualityComparer<SMFunction>`
`221`	`220`	`{`
`222`	`221`	`public bool Equals(SMFunction left, SMFunction right)`
`223`	`222`	`{`
`224`		`- return left.Name == right.Name;`
	`223`	`+ return left?.Name == right?.Name;`
`225`	`224`	`}`
`226`	`225`
`227`	`226`	`public int GetHashCode(SMFunction sm)`
`@@ -234,7 +233,7 @@ private class SMEnumComparer : IEqualityComparer<SMEnum>`
`234`	`233`	`{`
`235`	`234`	`public bool Equals(SMEnum left, SMEnum right)`
`236`	`235`	`{`
`237`		`- return left.Name == right.Name;`
	`236`	`+ return left?.Name == right?.Name;`
`238`	`237`	`}`
`239`	`238`
`240`	`239`	`public int GetHashCode(SMEnum sm)`
`@@ -247,7 +246,7 @@ private class SMStructComparer : IEqualityComparer<SMStruct>`
`247`	`246`	`{`
`248`	`247`	`public bool Equals(SMStruct left, SMStruct right)`
`249`	`248`	`{`
`250`		`- return left.Name == right.Name;`
	`249`	`+ return left?.Name == right?.Name;`
`251`	`250`	`}`
`252`	`251`
`253`	`252`	`public int GetHashCode(SMStruct sm)`
`@@ -260,7 +259,7 @@ private class SMDefineComparer : IEqualityComparer<SMDefine>`
`260`	`259`	`{`
`261`	`260`	`public bool Equals(SMDefine left, SMDefine right)`
`262`	`261`	`{`
`263`		`- return left.Name == right.Name;`
	`262`	`+ return left?.Name == right?.Name;`
`264`	`263`	`}`
`265`	`264`
`266`	`265`	`public int GetHashCode(SMDefine sm)`
`@@ -273,7 +272,7 @@ private class SMConstantComparer : IEqualityComparer<SMConstant>`
`273`	`272`	`{`
`274`	`273`	`public bool Equals(SMConstant left, SMConstant right)`
`275`	`274`	`{`
`276`		`- return left.Name == right.Name;`
	`275`	`+ return left?.Name == right?.Name;`
`277`	`276`	`}`
`278`	`277`
`279`	`278`	`public int GetHashCode(SMConstant sm)`
`@@ -286,7 +285,7 @@ private class SMMethodmapsComparer : IEqualityComparer<SMMethodmap>`
`286`	`285`	`{`
`287`	`286`	`public bool Equals(SMMethodmap left, SMMethodmap right)`
`288`	`287`	`{`
`289`		`- return left.Name == right.Name;`
	`288`	`+ return left?.Name == right?.Name;`
`290`	`289`	`}`
`291`	`290`
`292`	`291`	`public int GetHashCode(SMMethodmap sm)`
`@@ -307,7 +306,7 @@ public class ISNodeEqualityComparer : IEqualityComparer<ISNode>`
`307`	`306`	`{`
`308`	`307`	`public bool Equals(ISNode nodeA, ISNode nodeB)`
`309`	`308`	`{`
`310`		`- return nodeA.EntryName == nodeB.EntryName;`
	`309`	`+ return nodeA?.EntryName == nodeB?.EntryName;`
`311`	`310`	`}`
`312`	`311`
`313`	`312`	`public int GetHashCode(ISNode node)`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ public class SMFunction`
`6`	`6`	`{`
`7`	`7`	`public int Index = -1;`
`8`	`8`	`public int Length = 0;`
	`9`	`+ public int EndPos = -1;`
`9`	`10`	`public string File = string.Empty;`
`10`	`11`
`11`	`12`	`public string Name = string.Empty;`
`@@ -15,7 +16,6 @@ public class SMFunction`
`15`	`16`	`public string[] Parameters = new string[0];`
`16`	`17`	`public SMFunctionKind FunctionKind = SMFunctionKind.Unknown;`
`17`	`18`	`public List<SMVariable> FuncVariables = new List<SMVariable>();`
`18`		`- public string Body = string.Empty;`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`public enum SMFunctionKind`
Original file line number	Diff line number	Diff line change
`@@ -43,12 +43,14 @@ private void ParseDistributorTimer_Elapsed(object sender, ElapsedEventArgs args)`
`43`	`43`	`if (ee == null \|\| ce == null) return;`
`44`	`44`
`45`	`45`	`Debug.Assert(ee != null, nameof(ee) + " != null");`
	`46`	`+ // ReSharper disable once PossibleNullReferenceException`
`46`	`47`	`foreach (var e in ee)`
`47`	`48`	`if (e.LastSMDefUpdateUID < currentSMDefUID) //wants an update of the SMDefinition`
`48`	`49`	`{`
`49`	`50`	`if (e == ce)`
`50`	`51`	`{`
`51`	`52`	`Debug.Assert(ce != null, nameof(ce) + " != null");`
	`53`	`+ // ReSharper disable once PossibleNullReferenceException`
`52`	`54`	`if (ce.ISAC_Open) continue;`
`53`	`55`	`}`
`54`	`56`
`@@ -63,8 +65,11 @@ private void BackgroundParser_Worker()`
`63`	`65`	`while (true)`
`64`	`66`	`while (Program.OptionsObject.Program_DynamicISAC)`
`65`	`67`	`{`
`66`		`- Thread.Sleep(5000);`
	`68`	`+ Thread.Sleep(1000);`
`67`	`69`	`var ee = GetAllEditorElements();`
	`70`	`+ var caret = -1;`
	`71`	`+ var text = string.Empty;`
	`72`	`+`
`68`	`73`	`if (ee != null)`
`69`	`74`	`{`
`70`	`75`	`var definitions = new SMDefinition[ee.Length];`
`@@ -81,15 +86,19 @@ private void BackgroundParser_Worker()`
`81`	`86`	`Dispatcher.Invoke(() =>`
`82`	`87`	`{`
`83`	`88`	`if (ee[i1].IsLoaded)`
	`89`	`+ {`
	`90`	`+ caret = ee[i1].editor.CaretOffset;`
	`91`	`+ text = ee[i1].editor.Text;`
`84`	`92`	`definitions[i1] =`
`85`	`93`	`new Condenser(File.ReadAllText(fInfo.FullName), fInfo.Name)`
`86`	`94`	`.Condense();`
	`95`	`+ }`
`87`	`96`	`});`
`88`	`97`	`}`
`89`	`98`	`}`
`90`	`99`
`91`	`100`	`currentSMDef = Program.Configs[Program.SelectedConfig].GetSMDef()`
`92`		`- .ProduceTemporaryExpandedDefinition(definitions);`
	`101`	`+ .ProduceTemporaryExpandedDefinition(definitions, caret, text);`
`93`	`102`	`currentSMFunctions = currentSMDef.Functions.ToArray();`
`94`	`103`	`currentACNodes = currentSMDef.ProduceACNodes();`
`95`	`104`	`currentISNodes = currentSMDef.ProduceISNodes();`