First pass at implementing FindSymbolsVisitor and a few unit tests to test the functionality.

Author: rkeithhill

src/PowerShellEditorServices/Language/AstOperations.cs

@@ -131,8 +131,8 @@ static public IEnumerable<SymbolReference> FindReferencesOfSymbol(
             scriptAst.Visit(referencesVisitor);
 
             return referencesVisitor.FoundReferences;
-
         }
+
         /// <summary>
         /// Finds all references (not including aliases) in a script for the given symbol
         /// </summary>
@@ -172,6 +172,19 @@ static public SymbolReference FindDefinitionOfSymbol(
             return declarationVisitor.FoundDeclartion;
         }
 
+        /// <summary>
+        /// Finds all symbols in a script
+        /// </summary>
+        /// <param name="scriptAst">The abstract syntax tree of the given script</param>
+        /// <returns>A collection of SymbolReference objects</returns>
+        static public IEnumerable<SymbolReference> FindSymbolsInDocument(Ast scriptAst)
+        {
+            FindSymbolsVisitor findSymbolsVisitor = new FindSymbolsVisitor();
+            scriptAst.Visit(findSymbolsVisitor);
+
+            return findSymbolsVisitor.SymbolReferences;
+        }
+
         /// <summary>
         /// Finds all files dot sourced in a script
         /// </summary>

src/PowerShellEditorServices/Language/FindSymbolsVisitor.cs

@@ -0,0 +1,107 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Generic;
+using System.Management.Automation.Language;
+
+namespace Microsoft.PowerShell.EditorServices
+{
+    /// <summary>
+    /// The visitor used to find all the symbols (function and class defs) in the AST.
+    /// </summary>
+    internal class FindSymbolsVisitor : AstVisitor2
+    {
+        public List<SymbolReference> SymbolReferences { get; private set; }
+
+        public FindSymbolsVisitor()
+        {
+            this.SymbolReferences = new List<SymbolReference>();
+        }
+
+        /// <summary>
+        /// Adds each function defintion as a 
+        /// </summary>
+        /// <param name="functionDefinitionAst">A functionDefinitionAst object in the script's AST</param>
+        /// <returns>A decision to stop searching if the right symbol was found, 
+        /// or a decision to continue if it wasn't found</returns>
+        public override AstVisitAction VisitFunctionDefinition(FunctionDefinitionAst functionDefinitionAst)
+        {
+            IScriptExtent nameExtent = new ScriptExtent() {
+                Text = functionDefinitionAst.Name,
+                StartLineNumber = functionDefinitionAst.Extent.StartLineNumber,
+                EndLineNumber = functionDefinitionAst.Extent.EndLineNumber,
+                StartColumnNumber = functionDefinitionAst.Extent.StartColumnNumber,
+                EndColumnNumber = functionDefinitionAst.Extent.EndColumnNumber
+            };
+
+            SymbolType symbolType = 
+                functionDefinitionAst.IsWorkflow ? 
+                    SymbolType.Workflow : SymbolType.Function;
+
+            this.SymbolReferences.Add(
+                new SymbolReference(
+                    symbolType,
+                    nameExtent));
+
+            return AstVisitAction.Continue;
+        }
+
+        /// <summary>
+        ///  Checks to see if this variable expression is the symbol we are looking for.
+        /// </summary>
+        /// <param name="variableExpressionAst">A VariableExpressionAst object in the script's AST</param>
+        /// <returns>A descion to stop searching if the right symbol was found, 
+        /// or a decision to continue if it wasn't found</returns>
+        public override AstVisitAction VisitVariableExpression(VariableExpressionAst variableExpressionAst)
+        {
+            if (!IsAssignedAtScriptScope(variableExpressionAst))
+            {
+                return AstVisitAction.Continue;
+            }
+
+            this.SymbolReferences.Add(
+                new SymbolReference(
+                    SymbolType.Variable,
+                    variableExpressionAst.Extent));
+
+            return AstVisitAction.Continue;
+        }
+
+        public override AstVisitAction VisitConfigurationDefinition(ConfigurationDefinitionAst configurationDefinitionAst)
+        {
+            IScriptExtent nameExtent = new ScriptExtent() {
+                Text = configurationDefinitionAst.InstanceName.Extent.Text,
+                StartLineNumber = configurationDefinitionAst.Extent.StartLineNumber,
+                EndLineNumber = configurationDefinitionAst.Extent.EndLineNumber,
+                StartColumnNumber = configurationDefinitionAst.Extent.StartColumnNumber,
+                EndColumnNumber = configurationDefinitionAst.Extent.EndColumnNumber
+            };
+
+            this.SymbolReferences.Add(
+                new SymbolReference(
+                    SymbolType.Configuration,
+                    nameExtent));
+
+            return AstVisitAction.Continue;
+        }
+
+        private bool IsAssignedAtScriptScope(VariableExpressionAst variableExpressionAst)
+        {
+            Ast parent = variableExpressionAst.Parent;
+            if (!(parent is AssignmentStatementAst))
+            {
+                return false;
+            }
+
+            parent = parent.Parent;
+            if (parent == null || parent.Parent == null || parent.Parent.Parent == null)
+            {
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

src/PowerShellEditorServices/Language/LanguageService.cs

@@ -203,6 +203,32 @@ public async Task<SymbolDetails> FindSymbolDetailsAtLocation(
             return symbolDetails;
         }
 
+        /// <summary>
+        /// Finds all the symbols in a file.
+        /// </summary>
+        /// <param name="scriptFile">The ScriptFile in which the symbol can be located.</param>
+        /// <returns></returns>
+        public FindOccurrencesResult FindSymbolsInFile(ScriptFile scriptFile)
+        {
+            Validate.IsNotNull("scriptFile", scriptFile);
+
+            IEnumerable<SymbolReference> symbolReferencesinFile =
+                AstOperations
+                    .FindSymbolsInDocument(scriptFile.ScriptAst)
+                    .Select(
+                        reference => {
+                            reference.SourceLine =
+                                scriptFile.GetLine(reference.ScriptRegion.StartLineNumber);
+                            reference.FilePath = scriptFile.FilePath;
+                            return reference;
+                        });
+
+            return
+                new FindOccurrencesResult {
+                    FoundOccurrences = symbolReferencesinFile
+                };
+        }
+
         /// <summary>
         /// Finds all the references of a symbol
         /// </summary>

src/PowerShellEditorServices/Language/SymbolType.cs

@@ -28,8 +28,17 @@ public enum SymbolType
         /// <summary>
         /// The symbol is a parameter
         /// </summary>
-        Parameter
-    }
+        Parameter,
+
+        /// <summary>
+        /// The symbol is a DSC configuration
+        /// </summary>
+        Configuration,
 
+        /// <summary>
+        /// The symbol is a workflow
+        /// </summary>
+        Workflow,
+    }
 }
 

src/PowerShellEditorServices/PowerShellEditorServices.csproj

@@ -73,6 +73,7 @@
     <Compile Include="Language\FindOccurrencesResult.cs" />
     <Compile Include="Language\FindReferencesResult.cs" />
     <Compile Include="Language\FindReferencesVisitor.cs" />
+    <Compile Include="Language\FindSymbolsVisitor.cs" />
     <Compile Include="Language\FindSymbolVisitor.cs" />
     <Compile Include="Language\GetDefinitionResult.cs" />
     <Compile Include="Language\LanguageService.cs" />

test/PowerShellEditorServices.Test.Shared/PowerShellEditorServices.Test.Shared.csproj

@@ -55,13 +55,17 @@
     <Compile Include="References\FindsReferencesOnFunctionMultiFileDotSource.cs" />
     <Compile Include="References\FindsReferencesOnVariable.cs" />
     <Compile Include="SymbolDetails\FindsDetailsForBuiltInCommand.cs" />
+    <Compile Include="Symbols\FindSymbolsInMultiSymbolFile.cs" />
+    <Compile Include="Symbols\FindSymbolsInNoSymbolsFile.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Completion\CompletionExamples.psm1">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
     <None Include="Debugging\VariableTest.ps1" />
     <None Include="SymbolDetails\SymbolDetails.ps1" />
+    <None Include="Symbols\MultipleSymbols.ps1" />
+    <None Include="Symbols\NoSymbols.ps1" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\src\PowerShellEditorServices\PowerShellEditorServices.csproj">

test/PowerShellEditorServices.Test.Shared/Symbols/FindSymbolsInMultiSymbolFile.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.PowerShell.EditorServices.Test.Shared.Symbols
+{
+    public class FindSymbolsInMultiSymbolFile
+    {
+        public static readonly ScriptRegion SourceDetails =
+            new ScriptRegion {
+                File = @"Symbols\MultipleSymbols.ps1"
+            };
+    }
+}

test/PowerShellEditorServices.Test.Shared/Symbols/FindSymbolsInNoSymbolsFile.cs

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.PowerShell.EditorServices.Test.Shared.Symbols
+{
+    public class FindSymbolsInNoSymbolsFile
+    {
+        public static readonly ScriptRegion SourceDetails =
+            new ScriptRegion {
+                File = @"Symbols\NoSymbols.ps1"
+            };
+    }
+}

test/PowerShellEditorServices.Test.Shared/Symbols/MultipleSymbols.ps1

@@ -0,0 +1,31 @@
+$Global:GlobalVar = 0
+$UnqualifiedScriptVar = 1
+$Script:ScriptVar2 = 2
+
+"`$Script:ScriptVar2 is $Script:ScriptVar2"
+
+function AFunction {}
+
+filter AFilter {$_}
+
+function AnAdvancedFunction {
+    begin {
+        $LocalVar = 'LocalVar'
+        function ANestedFunction() {
+            $nestedVar = 42
+            "`$nestedVar is $nestedVar"
+        }
+    }
+    process {}
+    end {}
+}
+
+workflow AWorkflow {}
+
+Configuration AConfiguration {
+    Node "TEST-PC" {}
+}
+
+AFunction
+1..3 | AFilter
+AnAdvancedFunction

test/PowerShellEditorServices.Test.Shared/Symbols/NoSymbols.ps1

@@ -0,0 +1 @@
+# This file represents a script with no symbols

test/PowerShellEditorServices.Test/Language/LanguageServiceTests.cs

@@ -9,6 +9,7 @@
 using Microsoft.PowerShell.EditorServices.Test.Shared.ParameterHint;
 using Microsoft.PowerShell.EditorServices.Test.Shared.References;
 using Microsoft.PowerShell.EditorServices.Test.Shared.SymbolDetails;
+using Microsoft.PowerShell.EditorServices.Test.Shared.Symbols;
 using System;
 using System.IO;
 using System.Linq;
@@ -224,7 +225,44 @@ await this.languageService.FindSymbolDetailsAtLocation(
             Assert.NotNull(symbolDetails.Documentation);
             Assert.NotEqual("", symbolDetails.Documentation);
         }
-        
+
+        [Fact]
+        public void LanguageServiceFindsSymbolsInFile()
+        {
+            FindOccurrencesResult symbolsResult =
+                this.FindSymbolsInFile(
+                    FindSymbolsInMultiSymbolFile.SourceDetails);
+
+            Assert.Equal(4, symbolsResult.FoundOccurrences.Where(r => r.SymbolType == SymbolType.Function).Count());
+            Assert.Equal(3, symbolsResult.FoundOccurrences.Where(r => r.SymbolType == SymbolType.Variable).Count());
+            Assert.Equal(1, symbolsResult.FoundOccurrences.Where(r => r.SymbolType == SymbolType.Workflow).Count());
+
+            SymbolReference firstFunctionSymbol = symbolsResult.FoundOccurrences.Where(r => r.SymbolType == SymbolType.Function).First();
+            Assert.Equal("AFunction", firstFunctionSymbol.SymbolName);
+            Assert.Equal(7, firstFunctionSymbol.ScriptRegion.StartLineNumber);
+            Assert.Equal(1, firstFunctionSymbol.ScriptRegion.StartColumnNumber);
+
+            SymbolReference lastVariableSymbol = symbolsResult.FoundOccurrences.Where(r => r.SymbolType == SymbolType.Variable).Last();
+            Assert.Equal("$Script:ScriptVar2", lastVariableSymbol.SymbolName);
+            Assert.Equal(3, lastVariableSymbol.ScriptRegion.StartLineNumber);
+            Assert.Equal(1, lastVariableSymbol.ScriptRegion.StartColumnNumber);
+
+            SymbolReference firstWorkflowSymbol = symbolsResult.FoundOccurrences.Where(r => r.SymbolType == SymbolType.Workflow).First();
+            Assert.Equal("AWorkflow", firstWorkflowSymbol.SymbolName);
+            Assert.Equal(23, firstWorkflowSymbol.ScriptRegion.StartLineNumber);
+            Assert.Equal(1, firstWorkflowSymbol.ScriptRegion.StartColumnNumber);
+        }
+
+        [Fact]
+        public void LanguageServiceFindsSymbolsInNoSymbolsFile()
+        {
+            FindOccurrencesResult symbolsResult =
+                this.FindSymbolsInFile(
+                    FindSymbolsInNoSymbolsFile.SourceDetails);
+
+            Assert.Equal(0, symbolsResult.FoundOccurrences.Count());
+        }
+
         private ScriptFile GetScriptFile(ScriptRegion scriptRegion)
         {
             const string baseSharedScriptPath = 
@@ -304,5 +342,12 @@ private FindOccurrencesResult GetOccurrences(ScriptRegion scriptRegion)
                     scriptRegion.StartLineNumber,
                     scriptRegion.StartColumnNumber);
         }
+
+        private FindOccurrencesResult FindSymbolsInFile(ScriptRegion scriptRegion)
+        {
+            return
+                this.languageService.FindSymbolsInFile(
+                    GetScriptFile(scriptRegion));
+        }
     }
 }