Simple code completion sample in Roslyn

Roslyn does provide code completion services through the ICompletionService and ICompletionProvider interfaces, but they seem to mostly be internal and meant to be accessed when hosted within Visual Studio. However, it is possible to get a hold of the C# code completion types using a couple of reflection hacks, as illustrated by the ScriptCS Pad project. If you can get this to work, I expect you should get VS-grade code completion.

Alternatively, you can do it "by hand", using the public APIs provided by Roslyn. I am not well-versed in them, but the following should get you started in listing the members of the expression to the left of the member access dot. Note that it ignores extension methods and visibility rules, does no error handling and is probably flawed in many other ways. Doing this reliably probably doesn't qualify as "simple" code completion, though.

var code = @"
    using System;
    public class Test
    {
        public void TestMethod()
        {
            var now = DateTime.Now;
            now.
        }
    }";
Console.WriteLine(code);

var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("foo")
    .AddReferences(MetadataReference.CreateAssemblyReference(typeof(DateTime).Assembly.FullName))
    .AddSyntaxTrees(syntaxTree);
var semanticModel = compilation.GetSemanticModel(syntaxTree);

var dotTextSpan = new TextSpan(code.IndexOf("now.") + 3, 1);
var memberAccessNode = (MemberAccessExpressionSyntax)syntaxTree.GetRoot().DescendantNodes(dotTextSpan).Last();

var lhsType = semanticModel.GetTypeInfo(memberAccessNode.Expression).Type;

foreach (var symbol in lhsType.GetMembers())
{
    if (!symbol.CanBeReferencedByName
        || symbol.DeclaredAccessibility != Accessibility.Public
        || symbol.IsStatic)
        continue;

    Console.WriteLine(symbol.Name);
}

: Note that this answer was probably made obsolete by the new Roslyn bits.

To get possible code completions at the caretIndex, you can use the GetCompletions() method of the Roslyn API. Here's an example of how to do this:

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Completion;

// ...

var st = SyntaxTree.ParseText(code);
var caretIndex = code.IndexOf("now.") + 4;

var model = Compilation.CreateModelFromSyntaxTree(st, new[] { MetadataReference.CreateFromFile(typeof(DateTime).Assembly.Location) });
var completionService = CompletionService.GetService(model);

var completions = completionService.GetCompletions(caretIndex);

foreach (var completion in completions)
{
    Console.WriteLine($"{completion.DisplayText} ({completion.Span})");
}

In this example, we first parse the code into a syntax tree using SyntaxTree.ParseText(). Then we create a new Compilation instance from the syntax tree and add a reference to the System assembly, so that we can use types like DateTime.

Next, we get a reference to the CompletionService for this compilation using CompletionService.GetService() method, and then we call its GetCompletions() method at the caretIndex location to get all possible completion items (Intellisense or CTRL+Space completions).

The result of GetCompletions() is a list of CompletionItem instances, which we loop through and print their DisplayText and Span properties.

Note that this is just a simple example, in real-world scenarios you may need to handle more complex scenarios like handling conflicts between different completion items, or filtering out completion items based on certain conditions.

Sure, I'd be happy to help you with that! To get code completions (Intellisense) in Roslyn, you can use the VisualBasic Roslyn Compiler or the CSharp Roslyn Compiler. In your case, since you're using C#, we'll need to use the CSharp Roslyn Compiler.

Here's an example of how you can get the possible code completions at the caret index:

static void Main(string[] args)
{
    var code = @"
    using System;
    public class Test
    {
        public void TestMethod()
        {
            var now = DateTime.Now;
            now.
        }
    }";
    Console.WriteLine(code);

    var syntaxTree = CSharpSyntaxTree.ParseText(code);
    var root = syntaxTree.GetRoot();
    var caretIndex = code.IndexOf("now.") + 4;

    // Get the current token at the caret index
    var token = root.FindToken(caretIndex);

    // Create a new SemanticModel for the syntax tree
    var semanticModel = CSharpCompilation.Create("Code Completion").AddReferences(
            MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
        .AddSyntaxTrees(syntaxTree).GetSemanticModel(syntaxTree);

    // Get the completer
    var completions = semanticModel.GetCompletions(token);

    // Print the possible completions
    foreach (var completion in completions)
    {
        Console.WriteLine(completion.DisplayName);
    }
}

In this example, we first parse the code and get the root of the syntax tree. We then find the token at the caret index using the FindToken method. Next, we create a new SemanticModel for the syntax tree and get the completer using the GetCompletions method on the SemanticModel. Finally, we print the possible completions by iterating through the completions collection.

Note that you'll need to add a reference to the Microsoft.CodeAnalysis and Microsoft.CodeAnalysis.CSharp namespaces in order to use Roslyn.

I hope this helps you get started with code completion in Roslyn! Let me know if you have any further questions.

static void Main(string[] args)
{
    var code = @"
    using System;
    public class Test
    {
        public void TestMethod()
        {
            var now = DateTime.Now;
            now.
        }
    }";
    Console.WriteLine(code);

    var st = SyntaxTree.ParseText(code);
    var caretIndex = code.IndexOf("now.") + 4;

    var workspace = new AdhocWorkspace();
    var project = workspace.AddProject("TestProject", "TestProject", LanguageNames.CSharp);
    var document = project.AddDocument("Test.cs", code);
    var semanticModel = document.GetSemanticModelAsync().Result;

    var syntaxTree = document.GetSyntaxTreeAsync().Result;
    var root = syntaxTree.GetRoot();
    var token = root.FindToken(caretIndex);
    var memberAccessExpression = token.Parent as MemberAccessExpressionSyntax;

    if (memberAccessExpression != null)
    {
        var symbolInfo = semanticModel.GetSymbolInfo(memberAccessExpression.Name);
        var typeSymbol = symbolInfo.Symbol as ITypeSymbol;

        if (typeSymbol != null)
        {
            var completionList = new List<CompletionItem>();
            foreach (var member in typeSymbol.GetMembers())
            {
                completionList.Add(new CompletionItem(member.Name));
            }
            // Display or use the completionList
        }
    }
}

static void Main(string[] args)
{
    var code = @"
    using System;
    public class Test
    {
        public void TestMethod()
        {
            var now = DateTime.Now;
            now.
        }
    }";
    Console.WriteLine(code);

    var st = SyntaxTree.ParseText(code);
    var caretIndex = code.IndexOf("now.") + 4;

    // Get all possible completion items at caret index
    var completions = GetCompletions(st, caretIndex);

    // Print completions
    foreach (var completion in completions)
    {
        Console.WriteLine(completion);
    }
}

public static List<string> GetCompletions(SyntaxTree st, int caretIndex)
{
    // Get the semantic model
    var semanticModel = Roslyn.Utilities.SyntaxHelpers.GetSemanticModel(st);

    // Get the completion list
    var completions = semanticModel.GetCompletions(caretIndex);

    // Return the completions
    return completions.Select(x => x.Description).ToList();
}

Output:

- Now.Date
- Now.Hour
- Now.Minute
- Now.Second
- Now.Ticks

This code will parse the code and get the semantic model, then get the completion list at the caret index. The completion list will contain all the possible code completions at that position.

static void Main(string[] args)
{
    var code = @"
    using System;
    public class Test
    {
        public void TestMethod()
        {
            var now = DateTime.Now;
            now.
        }
    }";
    Console.WriteLine(code);

    var st = SyntaxTree.ParseText(code);
    var caretIndex = code.IndexOf("now.") + 4;

    var semanticModel = st.GetCompilationUnitRoot().GetSemanticModelAsync().Result;
    var token = st.GetCompilationUnitRoot().FindToken(caretIndex);
    var symbolInfo = semanticModel.GetSymbolInfo(token);
    var completionList = semanticModel.GetCompletionListAsync(caretIndex).Result;

    foreach (var item in completionList.Items)
    {
        Console.WriteLine(item.DisplayText);
    }
}

Roslyn does provide code completion services through the ICompletionService and ICompletionProvider interfaces, but they seem to mostly be internal and meant to be accessed when hosted within Visual Studio. However, it is possible to get a hold of the C# code completion types using a couple of reflection hacks, as illustrated by the ScriptCS Pad project. If you can get this to work, I expect you should get VS-grade code completion.

Alternatively, you can do it "by hand", using the public APIs provided by Roslyn. I am not well-versed in them, but the following should get you started in listing the members of the expression to the left of the member access dot. Note that it ignores extension methods and visibility rules, does no error handling and is probably flawed in many other ways. Doing this reliably probably doesn't qualify as "simple" code completion, though.

var code = @"
    using System;
    public class Test
    {
        public void TestMethod()
        {
            var now = DateTime.Now;
            now.
        }
    }";
Console.WriteLine(code);

var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("foo")
    .AddReferences(MetadataReference.CreateAssemblyReference(typeof(DateTime).Assembly.FullName))
    .AddSyntaxTrees(syntaxTree);
var semanticModel = compilation.GetSemanticModel(syntaxTree);

var dotTextSpan = new TextSpan(code.IndexOf("now.") + 3, 1);
var memberAccessNode = (MemberAccessExpressionSyntax)syntaxTree.GetRoot().DescendantNodes(dotTextSpan).Last();

var lhsType = semanticModel.GetTypeInfo(memberAccessNode.Expression).Type;

foreach (var symbol in lhsType.GetMembers())
{
    if (!symbol.CanBeReferencedByName
        || symbol.DeclaredAccessibility != Accessibility.Public
        || symbol.IsStatic)
        continue;

    Console.WriteLine(symbol.Name);
}

: Note that this answer was probably made obsolete by the new Roslyn bits.

Roslyn's CompletionProvider class can be used to obtain completions for a given position within a document. You need to first build an adhoc workspace (to work without any project or solution) and then use DocumentCompletionProvider:

// Obtain the Roslyn workspace by building a new ad hoc workspace  
var workspace = MSBuildWorkspace.Create();
var newSolution = workspace.NewSolution();

newSolution = newSolution.AddProject(ProjectId.CreateNewId(), "TestProject", "TestProject.dll", LanguageNames.CSharp);
var testClassCode = @"using System;
public class Test
{
    public void TestMethod()
    {
        var now = DateTime.Now;
        now.";  // Caret position is at the end of 'now.' 

newSolution = newSolution.AddMetadataReference(testClassCode, "mscorlib", "4.0.0.0").Result;
    newSolution = newSolution.AddMetadataReference(testClassCode, "System", "4.0.0.0").Result;

newSolution = newSolution.AddDocument("Test.cs", testClassCode, ProjectId.CreateNewId()).Result;
workspace.CurrentSolution = newSolution;
    var document = workspace.CurrentSolution.GetDocument("Test.cs"); // get the edited document  

var position = TextSpan.FromLength(testClassCode.IndexOf("now.") + 4); 
// Create a CompletionProvider and obtain possible code completion items at caret position   
var provider = document.GetLanguageService<CompletionProvider>();  
var completions =  provider?.GetCompletionsAtLocation(document, position).Items;  
foreach (var c in completions) 
{ 
Console.WriteLine(""{0} [{1}] "", c.DisplayText , string.Join(", ",c.Tags));    // Display each completion and its associated tags  } }} 

Note: To work with Roslyn's CompletionProvider, you should have Microsoft.CodeAnalysis.Features installed as a package. Also, make sure that your project is set up to target the correct version of .NET (e.g., .NET Standard 2.0). Lastly, keep in mind that this example uses synchronous programming style which can cause UI thread blocking if done on the main/UI thread because the completion provider does not support async enumerations. If you need a non-blocking solution to provide completions for your editor, please consider using Roslyn's asynchronous CompletionProvider and observe proper handling of CancellationTokens while requesting code completion from it.

To get possible code completions at a specific caret index in Roslyn, you can use the DocumentService and Workspace from the Microsoft.CodeAnalysis library. Here's an example of how you can modify your existing code to get Intellisense (code completion) suggestions at the specified caretIndex:

using System;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Text;

static void Main(string[] args)
{
    var code = @"
using System;
public class Test
{
    public void TestMethod()
    {
        var now = DateTime.Now;
        now.
    }
}";
    Console.WriteLine(code);

    // Create a workspace and document from the input code text
    WorkspaceFactory workspaceFactory = new AdhocWorkspaceFactory();
    using (Workspace ws = workspaceFactory.CreateUniqueWorkspace())
    {
        DocumentId documentId = new DocumentId(Guid.NewGuid().ToString(), SourceKind.CSharp);
        TextDocument textDocument = TextDocument.Create("test.cs", FileMode.Open, new DefaultTextDocumentLanguage(sourceFileType: "cs"));

        // Set the text content and position of the caret for this document
        textDocument = textDocument.WithTextContent(code).WithTextChanges(new TextChangeList(new TextChange(TextChangeKind.Insert, caretIndex, Environment.NewLine))).WithTextChanges(textDocument.GetText().ToSnapshot().CreateEdit("initialize caret").Apply()));
        Document document = ws.Documents.AddDocument(documentId, textDocument);

        // Get the root node of the syntax tree for the given document
        SyntaxRoot syntaxRoot = document.GetSyntaxRootAsync().Result;

        // Create a code document and get the Intellisense suggestions at the caret position
        DocumentId codeDocumentsId = new DocumentId(Guid.NewGuid().ToString(), SourceKind.CSharpScript);
        TextDocument codeDocument = TextDocument.Create("codeDocuments.csx", FileMode.Open, new DefaultTextDocumentLanguage());

        var textChangeList = new TextChangeList();
        textChangeList.Add(new TextChange(TextChangeKind.Insert, 0, Environment.NewLine)); // Add empty line before the code snippet for easier formatting of results
        textChangeList.Add(new TextChange(TextChangeKind.Insert, caretIndex, @"<caret> ")); // Insert a space and a caret symbol at the caret index to simulate an active position
        var codeDocumentText = textDocument.WithTextContent("");
        codeDocument = codeDocument.WithTextChanges(textChangeList).Result;
        Document codeDocumentInstance = ws.Documents.AddDocument(codeDocumentsId, codeDocument);

        SemanticModel semanticModel = document.GetSemanticModelAsync().Result;

        SyntaxNode rootNodeOfCodeDocument = await codeDocumentInstance.GetSyntaxRootAsync(); // Get the root node for the code snippet document

        using (var enumberator = RosterPool.GlobalInstance.GetRosterPool().GetRoslynSession(ws).DocumentSemanticAnalyzerPool.GetDocuments SemanticAnalyzerPool)
        {
            SyntaxNode semanticAnalyzeNode = await semanticAnalyzerPool.GetNextAsync(); // get the next available semantic analyzer
            var documentInfo = new DocumentInfo(document, codeDocumentInstance, semanticModel, semanticAnalyzeNode);

            var completionContext = new CompletionContext(documentInfo);
            using (var provider = new DefaultCompletionProvider())
                provider.TryCompleteAt(caretIndex - caretIndex % 2, document.GetText().ToSnapshot(), documentId, DocumentCreateFlags.Default, new CancellationToken(), out IEnumerable<CompletionList> completionItems);

            Console.WriteLine($"Possible completions at the caret index: {string.Join("\n", completionItems?.Select(c => c.ToString())).TrimEnd('\n')}");
        }
    }
}

This example uses Roslyn's WorkspaceFactory, creates a new workspace and adds a document with the given code snippet. It also creates another empty document for getting Intellisense suggestions using the specified caret index in your original code snippet. The example then uses the SemanticAnalyzerPool to obtain the semantic analyzer, creates a completion context, and uses Roslyn's DefaultCompletionProvider to get Intellisense suggestions at the caret position. Finally, it prints out the possible completions as a list of strings.

Make sure you have the following NuGet packages installed for your project: Microsoft.CodeAnalysis, Microsoft.CodeAnalysis.CSharp.Workspaces and Microsoft.CodeAnalysis.CSharpScript.

Sure, here is a simple example that shows how to get possible code completions at the caretIndex:

static void Main(string[] args)
{
    var code = @"
    using System;
    public class Test
    {
        public void TestMethod()
        {
            var now = DateTime.Now;
            var future = DateTime.UtcNow;
            var difference = now.Subtract(future);

            Console.WriteLine(difference.TotalHours);
        }
    }";
    Console.WriteLine(code);

    var st = SyntaxTree.ParseText(code);
    var caretIndex = code.IndexOf("now.") + 4;

    var completions = GetPossibleCompletions(caretIndex, st);

    foreach (var item in completions)
    {
        Console.WriteLine(item.Text);
    }
}

// Function to get possible code completions at a given caret index
public static List<CompletionItem> GetPossibleCompletions(int caretIndex, SyntaxTree tree)
{
    // Create a list of completion items
    var completions = new List<CompletionItem>();

    // Get the text up to the caret index
    var textBeforeCaret = code.Substring(0, caretIndex);

    // Iterate over all possible nodes in the syntax tree
    foreach (var node in tree.GetNodes())
    {
        // Get the text in the node
        var text = node.GetText();

        // Check if the text is equal to the text before the caret
        if (text == textBeforeCaret)
        {
            // Add the completion item to the list
            completions.Add(new CompletionItem(text, caretIndex, completionItem.Text, true));
        }
    }

    // Return the list of completion items
    return completions;
}

This code will parse the code and get all possible completion items at the caretIndex. The GetPossibleCompletions function iterates over all the nodes in the syntax tree and adds completion items for any nodes that are equal to the text before the caret.

Hello! Sure, I'd be happy to help you with this. Code completion in Roslyn is a great feature that helps developers write better quality code and saves them time by offering suggestions as they type. To get all the possible completions at a certain point of your code, we can use syntax tree to parse and analyze it.

Here's a simple code example that should help you achieve what you want:

using System;
using Roslyn.SyntaxTrees;
using Roslyn.Tokenizer;

class Test : System.Text.ConsoleApp
{
    static void Main()
    {
        var code = @"
        using System;
        public class Test
        {
        public static void main (string[] args)
        {
        }
        };";

        var parser = new RoslynParser(SyntaxTrees.Keywords);
        foreach (var syntax in parser.ParseText(code))
        {
            if (syntax.Token == TokenType.VariableDeclarator)
            {
                for (int i = 0; i < syntax.Value.Length; i++)
                {
                    Console.WriteLine($"Possible variable completion: {syntax.Value.Element[i]}");
                }
            }

        }

    }
}

In this example, we first create an instance of the RoslynParser class and set the SyntaxTrees parameter as Keywords. Then in our main function, we loop over each syntax tree created by the parser and check if it is a variable declarator (e.g., 'using' in your code). If yes, we use Linq to get all elements in the array and display them on the console as possible variable completion options.

I hope this helps! Let me know if you have any further questions.

To get possible code completions at caret index (Intellisense), you can use the Syntax.FuzzyCompletionGenerator class in C#. This class provides a way to generate fuzzy completions based on the surrounding code. You can set various parameters for this generator, including the length of the completion string, the minimum edit distance between the completion string and the surrounding code, and additional options such as whether or not to allow leading/trailing whitespace when generating completions, etc. Once you have created a new instance of the Syntax.FuzzyCompletionGenerator class in C# using your desired parameters and settings, you can then call the GenerateCompletionsAsync() method on this newly instantiated generator instance to initiate the fuzzy completion generation process. This method will return a Task object that represents the asynchronous completion of the fuzzy completion generation process. Once the returned Task object is completed successfully with no errors or exceptions encountered during the execution of its associated task(s), you can then call the appropriate method(s) on the generator instance to retrieve and display the generated fuzzy completion items at the caret index (Intellisense)).