实例分析SharpDevelop代码完成功能

介绍

SharpDevelop的源代码里自带一个CSharp代码自动完成功能（Code Completion）的例子。如下图所示：

 

图1. 代码完成

看上去似乎好像挺不好做的，理论上要做词法分析、语法分析，还要解析一些如mscorlib之类的DLL。但是事实上SharpDevelop已经为我们做了这些，上面的例子只要写几个类就可以完成。整个Solution如下图所示：

图2. 代码完成例子的Solution

图3. Code Metrics Results

直接使用SharpDevelop里的分析器，就可以很简单地完成Code Completion的功能。平均每个文件只有100行的代码。也许有人要说这样没有意思，但是我们不应该“重新做个轮子”对吗？而且就算要深入地学习，也要先来把这个例子弄明白的。

这个例子里的Code Completion并不象SharpDevelop里的那么完成，没有提供下面的功能。

图4. 缺失的ToolTip提示

在输入左括号时，应该在ToolTip中给出这个函数的所有重载，但是这个例子里并没有给出这个功能的实现。下面在介绍代码完成的同时，会给出这个ToolTip的实现。

博客园的Michael Zhang在其SharpDevelop浅析系列文章中也介绍了代码完成功能。如果对整个SharpDevelop有兴趣可以参考一下。下面进入正题……

第一部分 Code Completion的实现

下图是这个例子里的类体系

图5. 整个例子的类体系

从类的结构来看，其实与SharpDevelop本身的实现不是一个层次的，这个类结构的耦合性很强，还好要看的是如何实现Code Completion，而不是它的设计。要看设计，还是看SharpDevelop好了。

下面逐个介绍一下里面的类。

l CodeCompletionData类：是用于表示代码完成列表中每个项的Visual Object。看看它的父类会更明显一些。

图6. DefaultCompletionData类图

l MainForm类：就是看到的整个窗体。里面有三个控件，一个是SharpDevelop的TextEditorControl，一个状态栏，一个ImageList。主窗体加载之后会开启一个Parser线程，每2秒对整个文档做一次Parse。（汗，用Stopwatch测试了一下，对一个很小的文件的一次Parse要50ms左右。）Parse之后，用于做Code Completion的数据就有了。在哪儿？没去认真找过。应该是在ProjectContent里。下面是Parse的步骤：

 

 1        void ParseStep()
 2        {
 3            string code = null;
 4            Invoke(new MethodInvoker(delegate {
 5                                         code = textEditorControl1.Text;
 6                                     }));
 7            TextReader textReader = new StringReader(code);
 8            Dom.ICompilationUnit newCompilationUnit;
 9            NRefactory.SupportedLanguage supportedLanguage;
            if (IsVisualBasic)
                supportedLanguage = NRefactory.SupportedLanguage.VBNet;
            else
                supportedLanguage = NRefactory.SupportedLanguage.CSharp;
            using (NRefactory.IParser p = NRefactory.ParserFactory.CreateParser(supportedLanguage, textReader)) {
                // we only need to parse types and method definitions, no method bodies
                // so speed up the parser and make it more resistent to syntax
                // errors in methods
                p.ParseMethodBodies = false;
                
                p.Parse();
                newCompilationUnit = ConvertCompilationUnit(p.CompilationUnit);
            }
            // Remove information from lastCompilationUnit and add information from newCompilationUnit.
            myProjectContent.UpdateCompilationUnit(lastCompilationUnit, newCompilationUnit, DummyFileName);
            lastCompilationUnit = newCompilationUnit;
            parseInformation.SetCompilationUnit(newCompilationUnit);
        }

 

l CodeCompletionKeyHandler类：看名字就知道，就是针对CodeCompletion处理窗体的键盘事件的，如果点了”.”，就实例化一个CodeCompletionProvider并显示CodeCompletion窗口。按VS的分析，这个只有22行代码的文件就不细介绍了。

 

 1            if (key == '.') {
 2                ICompletionDataProvider completionDataProvider = new CodeCompletionProvider(mainForm);
 3                
 4                codeCompletionWindow = CodeCompletionWindow.ShowCompletionWindow(
 5                    mainForm,                    // The parent window for the completion window
 6                    editor,                     // The text editor to show the window for
 7                    MainForm.DummyFileName,        // Filename - will be passed back to the provider
 8                    completionDataProvider,        // Provider to get the list of possible completions
 9                    key                            // Key pressed - will be passed to the provider
                );
                if (codeCompletionWindow != null) {
                    // ShowCompletionWindow can return null when the provider returns an empty list
                    codeCompletionWindow.Closed += new EventHandler(CloseCodeCompletionWindow);
                }
            }

 

l HostCallbackImplementation类：这个更少，就13行代码。做的事件就是后台分析出错的时候，把消息显示出来。

l CodeCompletionProvider类：虽然最重要的部分，却也只有51行代码。主要完成了两件事情：1. 生成CodeCompletion列表。2. 用户触发一个Item的时候把相应的内容插入（就2行）。

生成CodeCompletion列表的功能也十分简单，大致分成三个步骤：

a.       FindExpression：就是找到当前用户的点”.”之前的那个东西到底是个什么东西。

b.       Resolve：得到找到的那个东西的Memeber列表。

c.       GenerateData：从得到的列表生成用于在UI上显示的CodeCompletionData。

l ToolTipProvider类：这个可不是那个缺失的功能哦。这个只是在MouseOver一个Member时，显示出一些信息。在图1的上面的那个就是了。（好像ToolTip还错了……）这个过程和CodeCompletionProvider大致相同。就不再赘述了。

这样，整个CodeCompletion的功能就完成了。整个例子359行代码。（仔细看看代码，你会有信心把它到缩减到200行。）

第二部分 添加Code Insight功能

什么是Code Insight?就是之前提到的缺失的ToolTip啊。在SharpDevelop里给了它一个更专业的名字叫“Code Insight”。

一向奉行“Don’t recreate the wheel”，这次也不例外。Sample没有，SharpDevelop有啊。Ctrl+V过来不就行了？（当然商业项目不行哦，连Sample也不行。人家是GPL）

然后就在SharpDevelop的源代码中找到了一个名为MethodInsightDataProvider的文件（在ICSharpCode.SharpDevelop.DefaultEditor.Gui.Editor名字空间下）加了进来，然后在KeyHandler里加入对InsightWindow的支持。

 

else if (key == '(')
{
    IInsightDataProvider insightDataProvider = new MethodInsightDataProvider(mainForm);

    InsightWindow insightWindow = new InsightWindow(mainForm, editor);
    insightWindow.AddInsightDataProvider(insightDataProvider, MainForm.DummyFileName);
    insightWindow.ShowInsightWindow();
}

再把SharpDevelop里的CodeCompletionData里的GetDocumentation函数也Copy到这个Sample的CodeCompletionData类中。

这样所有的类的准备完了。

然而在MethodInsightDataProvider中使用到的ParserService、AmbienceService、LoggingService和MessageService都没有找到引用。又去看了一下SharpDevelop的运行流程，找到了开启这几个Service的地方，发现差不多也已经同时把整个IDE开启了。这个可不是我想要的。而且很多类都是protected sealed类。从外界是Call不到的。看来必须要”Recreate the wheel”，把那个DataProvider重新写一个了。还好那个Provider只有100多行代码，自己写一个并不复杂。把LoggingService和MessageService的代码都删除。而ParserService和AmbienceService的作用不过是Parser和Ambience的工厂类，自己实例化一个不就得了？这样，DataProvider中所引用的所有Service都被剥离了。

整个MethodInsightDataProvider的代码如下所示：

 

  1// <file>
  2//     <copyright see="prj:///doc/copyright.txt"/>
  3//     <license see="prj:///doc/license.txt"/>
  4//     <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
  5//     <modifier name="Hugo Gu" email="nankezhishi@gmail.com"
  6//     <version>$Revision: 3105 $</version>
  7// </file>
  8
  9using System;
 10using System.Collections;
 11using System.Collections.Generic;
 12using System.Linq;
 13using System.Text;
 14using ICSharpCode.SharpDevelop.Dom;
 15using ICSharpCode.SharpDevelop.Dom.CSharp;
 16using ICSharpCode.SharpDevelop.Dom.NRefactoryResolver;
 17using ICSharpCode.SharpDevelop.Dom.VBNet;
 18using ICSharpCode.TextEditor;
 19using ICSharpCode.TextEditor.Document;
 20using ICSharpCode.TextEditor.Gui.InsightWindow;
 21
 22namespace CSharpEditor
 23{
 24    class MethodInsightDataProvider : IInsightDataProvider
 25    {
 26        MainForm mainForm;
 27        string fileName = null;
 28        IDocument document = null;
 29        TextArea textArea = null;
 30        protected List<IMethodOrProperty> methods = new List<IMethodOrProperty>();
 31
 32        public List<IMethodOrProperty> Methods
 33        {
 34            get
 35            {
 36                return methods;
 37            }
 38        }
 39
 40        public int InsightDataCount
 41        {
 42            get
 43            {
 44                return methods.Count;
 45            }
 46        }
 47
 48        int defaultIndex = -1;
 49
 50        public int DefaultIndex
 51        {
 52            get
 53            {
 54                return defaultIndex;
 55            }
 56            set
 57            {
 58                defaultIndex = value;
 59            }
 60        }
 61
 62        public string GetInsightData(int number)
 63        {
 64            IMember method = methods[number];
 65            IAmbience conv = MainForm.IsVisualBasic ? (IAmbience)new VBNetAmbience() : new CSharpAmbience();
 66            conv.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
 67            string documentation = method.Documentation;
 68            string text = conv.Convert(method);
 69            return text + "\n" + CodeCompletionData.GetDocumentation(documentation);
 70        }
 71
 72        int lookupOffset = -1;
 73        bool setupOnlyOnce;
 74
 75        /**//// <summary>
 76        /// 
 77        /// </summary>
 78        /// <param name="mainForm"></param>
 79        public MethodInsightDataProvider(MainForm mainForm)
 80        {
 81            this.mainForm = mainForm;
 82        }
 83
 84        /**//// <summary>
 85        /// Creates a MethodInsightDataProvider looking at the specified position.
 86        /// </summary>
 87        public MethodInsightDataProvider(int lookupOffset, bool setupOnlyOnce)
 88        {
 89            this.lookupOffset = lookupOffset;
 90            this.setupOnlyOnce = setupOnlyOnce;
 91        }
 92
 93        int initialOffset;
 94
 95        public void SetupDataProvider(string fileName, TextArea textArea)
 96        {
 97            if (setupOnlyOnce && this.textArea != null) return;
 98            IDocument document = textArea.Document;
 99            this.fileName = fileName;
            this.document = document;
            this.textArea = textArea;
            int useOffset = (lookupOffset < 0) ? textArea.Caret.Offset : lookupOffset;
            initialOffset = useOffset;

            IExpressionFinder expressionFinder;
            if (MainForm.IsVisualBasic)
            {
                expressionFinder = new VBExpressionFinder();
            }
            else
            {
                expressionFinder = new CSharpExpressionFinder(mainForm.parseInformation);
            }

            ExpressionResult expressionResult;
            if (expressionFinder == null)
                expressionResult = new ExpressionResult(TextUtilities.GetExpressionBeforeOffset(textArea, useOffset));
            else
                expressionResult = expressionFinder.FindExpression(textArea.Document.TextContent, useOffset);

            if (expressionResult.Expression == null) // expression is null when cursor is in string/comment
                return;
            expressionResult.Expression = expressionResult.Expression.Trim();

            int caretLineNumber = document.GetLineNumberForOffset(useOffset);
            int caretColumn = useOffset - document.GetLineSegment(caretLineNumber).Offset;
            // the parser works with 1 based coordinates
            SetupDataProvider(fileName, document, expressionResult, caretLineNumber + 1, caretColumn + 1);
        }

        protected virtual void SetupDataProvider(string fileName, IDocument document, ExpressionResult expressionResult, int caretLineNumber, int caretColumn)
        {
            bool constructorInsight = false;
            if (expressionResult.Context == ExpressionContext.Attribute)
            {
                constructorInsight = true;
            }
            else if (expressionResult.Context.IsObjectCreation)
            {
                constructorInsight = true;
                expressionResult.Context = ExpressionContext.Type;
            }
            else if (expressionResult.Context == ExpressionContext.BaseConstructorCall)
            {
                constructorInsight = true;
            }

            NRefactoryResolver resolver = new NRefactoryResolver(mainForm.myProjectContent.Language);

            ResolveResult results = resolver.Resolve(expressionResult, mainForm.parseInformation, document.TextContent);
            LanguageProperties language = mainForm.myProjectContent.Language;
            TypeResolveResult trr = results as TypeResolveResult;
            if (trr == null && language.AllowObjectConstructionOutsideContext)
            {
                if (results is MixedResolveResult)
                    trr = (results as MixedResolveResult).TypeResult;
            }
            if (trr != null && !constructorInsight)
            {
                if (language.AllowObjectConstructionOutsideContext)
                    constructorInsight = true;
            }
            if (constructorInsight)
            {
                if (trr == null)
                {
                    if ((expressionResult.Expression == "this") && (expressionResult.Context == ExpressionContext.BaseConstructorCall))
                    {
                        methods.AddRange(GetConstructorMethods(results.ResolvedType.GetMethods()));
                    }

                    if ((expressionResult.Expression == "base") && (expressionResult.Context == ExpressionContext.BaseConstructorCall))
                    {
                        if (results.CallingClass.BaseType.DotNetName == "System.Object")
                            return;
                        methods.AddRange(GetConstructorMethods(results.CallingClass.BaseType.GetMethods()));
                    }
                }
                else
                {
                    methods.AddRange(GetConstructorMethods(trr.ResolvedType.GetMethods()));

                    if (methods.Count == 0 && trr.ResolvedClass != null && !trr.ResolvedClass.IsAbstract && !trr.ResolvedClass.IsStatic)
                    {
                        // add default constructor
                        methods.Add(Constructor.CreateDefault(trr.ResolvedClass));
                    }
                }
            }
            else
            {
                MethodGroupResolveResult result = results as MethodGroupResolveResult;
                if (result == null)
                    return;
                bool classIsInInheritanceTree = false;
                if (result.CallingClass != null)
                    classIsInInheritanceTree = result.CallingClass.IsTypeInInheritanceTree(result.ContainingType.GetUnderlyingClass());

                foreach (IMethod method in result.ContainingType.GetMethods())
                {
                    if (language.NameComparer.Equals(method.Name, result.Name))
                    {
                        if (method.IsAccessible(result.CallingClass, classIsInInheritanceTree))
                        {
                            methods.Add(method);
                        }
                    }
                }
                if (methods.Count == 0 && result.CallingClass != null && language.SupportsExtensionMethods)
                {
                    ArrayList list = new ArrayList();
                    ResolveResult.AddExtensions(language, list, result.CallingClass, result.ContainingType);
                    foreach (IMethodOrProperty mp in list)
                    {
                        if (language.NameComparer.Equals(mp.Name, result.Name) && mp is IMethod)
                        {
                            DefaultMethod m = (DefaultMethod)mp.CreateSpecializedMember();
                            // for the insight window, remove first parameter and mark the
                            // method as normal - this is required to show the list of
                            // parameters the method expects.
                            m.IsExtensionMethod = false;
                            m.Parameters.RemoveAt(0);
                            methods.Add(m);
                        }
                    }
                }
            }
        }

        List<IMethodOrProperty> GetConstructorMethods(List<IMethod> methods)
        {
            List<IMethodOrProperty> constructorMethods = new List<IMethodOrProperty>();
            foreach (IMethod method in methods)
            {
                if (method.IsConstructor && !method.IsStatic)
                {
                    constructorMethods.Add(method);
                }
            }
            return constructorMethods;
        }

        public bool CaretOffsetChanged()
        {
            bool closeDataProvider = textArea.Caret.Offset <= initialOffset;
            int brackets = 0;
            int curlyBrackets = 0;
            if (!closeDataProvider)
            {
                bool insideChar = false;
                bool insideString = false;
                for (int offset = initialOffset; offset < Math.Min(textArea.Caret.Offset, document.TextLength); ++offset)
                {
                    char ch = document.GetCharAt(offset);
                    switch (ch)
                    {
                        case '\'':
                            insideChar = !insideChar;
                            break;
                        case '(':
                            if (!(insideChar || insideString))
                            {
                                ++brackets;
                            }
                            break;
                        case ')':
                            if (!(insideChar || insideString))
                            {
                                --brackets;
                            }
                            if (brackets <= 0)
                            {
                                return true;
                            }
                            break;
                        case '"':
                            insideString = !insideString;
                            break;
                        case '}':
                            if (!(insideChar || insideString))
                            {
                                --curlyBrackets;
                            }
                            if (curlyBrackets < 0)
                            {
                                return true;
                            }
                            break;
                        case '{':
                            if (!(insideChar || insideString))
                            {
                                ++curlyBrackets;
                            }
                            break;
                        case ';':
                            if (!(insideChar || insideString))
                            {
                                return true;
                            }
                            break;
                    }
                }
            }

            return closeDataProvider;
        }

        public bool CharTyped()
        {
            return false;
        }
    }
}

运行一下。

图7. Method Insight

大功告成。

其实还有一种Insight——IndexerInsight。就是在输入‘[’的时候给出ToolTip提示。这个就留给有兴趣的读者吧。

/Files/nankezhishi/source/CSharpCodeCompletion.zip这里是改版的代码完成的所有代码。

在下一篇中，将为这个示例添加Boo语言的支持。