Changeset 11800 for branches

Timestamp:

01/20/15 12:16:25 (10 years ago)

Author:

jkarder

Message:

#2077:

• added background parser to provide code completion for the scripted code
• minor code changes

Location:

branches/CodeEditor/HeuristicLab.CodeEditor/3.4

Files:

• HeuristicLab.CodeEditor-3.4.csproj (modified) (1 diff)
• LanguageFeatures/CodeCompletion/CSharp/CSharpCodeCompletionContext.cs (modified) (2 diffs)
• LanguageFeatures/CodeCompletion/CSharp/CSharpCodeCompletionHelpers.cs (added)
• LanguageFeatures/CodeCompletion/CSharp/CSharpCodeCompletionStrategy.cs (modified) (2 diffs)
• LanguageFeatures/CodeCompletion/CodeCompletionResult.cs (modified) (1 diff)
• LanguageFeatures/CodeCompletion/CodeCompletionStrategy.cs (modified) (5 diffs)
• LanguageFeatures/Interfaces/ICodeCompletionStrategy.cs (modified) (1 diff)
• LanguageFeatures/LanguageFeatures.cs (modified) (1 diff)

branches/CodeEditor/HeuristicLab.CodeEditor/3.4/HeuristicLab.CodeEditor-3.4.csproj

@@ -150 +150 @@
     <Compile Include="LanguageFeatures\CodeCompletion\CSharp\CSharpCodeCompletionContext.cs" />
     <Compile Include="LanguageFeatures\CodeCompletion\CSharp\CSharpCodeCompletionDataFactory.cs" />
+    <Compile Include="LanguageFeatures\CodeCompletion\CSharp\CSharpCodeCompletionHelpers.cs" />
     <Compile Include="LanguageFeatures\CodeCompletion\CSharp\CompletionData\EntityCompletionData.cs" />
     <Compile Include="LanguageFeatures\CodeCompletion\CSharp\CompletionData\ImportCompletionData.cs" />

branches/CodeEditor/HeuristicLab.CodeEditor/3.4/LanguageFeatures/CodeCompletion/CSharp/CSharpCodeCompletionContext.cs

@@ -20 +20 @@
 #endregion
 
-using ICSharpCode.NRefactory.CSharp;
 using ICSharpCode.NRefactory.CSharp.Completion;
-using ICSharpCode.NRefactory.CSharp.Resolver;
 using ICSharpCode.NRefactory.CSharp.TypeSystem;
 using ICSharpCode.NRefactory.Editor;
@@ -29 +27 @@
 namespace HeuristicLab.CodeEditor {
   internal class CSharpCodeCompletionContext {
-    public readonly IDocument Document;
-    public readonly int Offset;
-    public readonly IProjectContent ProjectContent;
-    public readonly ICompilation Compilation;
-    public readonly CSharpResolver Resolver;
-    public readonly CSharpTypeResolveContext TypeResolveContextAtCaret;
-    public readonly ICompletionContextProvider CompletionContextProvider;
+    private readonly IDocument document;
+    public IDocument Document { get { return document; } }
+
+    private readonly int offset;
+    public int Offset { get { return offset; } }
+
+    private readonly IProjectContent projectContent;
+    public IProjectContent ProjectContent { get { return projectContent; } }
+
+    private readonly CSharpTypeResolveContext typeResolveContextAtCaret;
+    public CSharpTypeResolveContext TypeResolveContextAtCaret { get { return typeResolveContextAtCaret; } }
+
+    private readonly ICompletionContextProvider completionContextProvider;
+    public ICompletionContextProvider CompletionContextProvider { get { return completionContextProvider; } }
 
     public CSharpCodeCompletionContext(IDocument document, int offset, IProjectContent projectContent) {
-      Document = new ReadOnlyDocument(document, document.FileName);
-      Offset = offset;
+      this.document = new ReadOnlyDocument(document, document.FileName);
+      this.offset = offset;
 
-      var parser = new CSharpParser();
-      var syntaxTree = parser.Parse(document, document.FileName);
-      syntaxTree.Freeze();
-      var unresolvedFile = syntaxTree.ToTypeSystem();
+      var unresolvedFile = CSharpCodeCompletionHelpers.CreateCSharpUnresolvedFile(this.document);
+      this.projectContent = projectContent.AddOrUpdateFiles(unresolvedFile);
 
-      ProjectContent = projectContent.AddOrUpdateFiles(unresolvedFile);
-      Compilation = projectContent.CreateCompilation();
+      completionContextProvider = new DefaultCompletionContextProvider(this.document, unresolvedFile);
 
-      var location = document.GetLocation(offset);
-      Resolver = unresolvedFile.GetResolver(Compilation, location);
-      TypeResolveContextAtCaret = unresolvedFile.GetTypeResolveContext(Compilation, location);
-      CompletionContextProvider = new DefaultCompletionContextProvider(document, unresolvedFile);
+      var compilation = this.projectContent.CreateCompilation();
+      var location = this.document.GetLocation(this.offset);
+      typeResolveContextAtCaret = unresolvedFile.GetTypeResolveContext(compilation, location);
     }
   }

branches/CodeEditor/HeuristicLab.CodeEditor/3.4/LanguageFeatures/CodeCompletion/CSharp/CSharpCodeCompletionStrategy.cs

@@ -26 +26 @@
 using ICSharpCode.NRefactory.CSharp;
 using ICSharpCode.NRefactory.CSharp.Completion;
+using ICSharpCode.NRefactory.Editor;
 using ICSharpCode.NRefactory.TypeSystem;
 
@@ -92 +93 @@
           }
         }
+      }
 
-        if (!controlSpace) {
-          var pce = new CSharpParameterCompletionEngine(
-            completionContext.Document,
-            completionContext.CompletionContextProvider,
-            completionFactory,
-            completionContext.ProjectContent,
-            completionContext.TypeResolveContextAtCaret
-          );
+      if (!controlSpace) {
+        var pce = new CSharpParameterCompletionEngine(
+          completionContext.Document,
+          completionContext.CompletionContextProvider,
+          completionFactory,
+          completionContext.ProjectContent,
+          completionContext.TypeResolveContextAtCaret
+        );
 
-          var parameterDataProvider = pce.GetParameterDataProvider(completionContext.Offset, completionChar);
-          result.OverloadProvider = parameterDataProvider as IUpdatableOverloadProvider;
-        }
+        var parameterDataProvider = pce.GetParameterDataProvider(completionContext.Offset, completionChar);
+        result.OverloadProvider = parameterDataProvider as IUpdatableOverloadProvider;
       }
 
       return result;
     }
+
+    protected override void DoParseStep() {
+      var document = (IDocument)codeEditor.Invoke(
+        (Func<IDocument>)(() => {
+          var doc = codeEditor.TextEditor.Document;
+          return new ReadOnlyDocument(doc, doc.FileName);
+        })
+      );
+
+      var unresolvedFile = CSharpCodeCompletionHelpers.CreateCSharpUnresolvedFile(document);
+      projectContent = projectContent.AddOrUpdateFiles(unresolvedFile);
+    }
   }
 }

branches/CodeEditor/HeuristicLab.CodeEditor/3.4/LanguageFeatures/CodeCompletion/CodeCompletionResult.cs

@@ -25 +25 @@
 namespace HeuristicLab.CodeEditor {
   internal class CodeCompletionResult {
-    public List<ICompletionData> CompletionData = new List<ICompletionData>();
-    public int TriggerWordLength;
-    public string TriggerWord;
+    public IList<ICompletionData> CompletionData { get; set; }
+    public int TriggerWordLength { get; set; }
+    public string TriggerWord { get; set; }
+    public IOverloadProvider OverloadProvider { get; set; }
 
-    public IOverloadProvider OverloadProvider;
+    public CodeCompletionResult() {
+      CompletionData = new List<ICompletionData>();
+    }
   }
 }

branches/CodeEditor/HeuristicLab.CodeEditor/3.4/LanguageFeatures/CodeCompletion/CodeCompletionStrategy.cs

@@ -21 +21 @@
 
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using ICSharpCode.AvalonEdit.CodeCompletion;
 
@@ -26 +28 @@
   internal abstract class CodeCompletionStrategy : ICodeCompletionStrategy {
     protected readonly CodeEditor codeEditor;
+    protected readonly Task backgroundParser;
 
     protected CodeCompletionStrategy(CodeEditor codeEditor) {
       this.codeEditor = codeEditor;
+      backgroundParser = new Task(DoBackgroundParsing);
     }
 
@@ -36 +40 @@
     }
 
+    public virtual void RunBackgroundParser() {
+      backgroundParser.Start();
+    }
+
     protected abstract CodeCompletionResult GetCodeCompletionResult(bool controlSpace);
+    protected abstract void DoParseStep();
 
     protected virtual void ApplyCodeCompletionData(CodeCompletionResult codeCompletionResult) {
@@ -57 +66 @@
 
         var data = cw.CompletionList.CompletionData;
-        foreach (var completion in codeCompletionResult.CompletionData.OrderBy(x => x.Text))
+        var newData = codeCompletionResult.CompletionData.OrderBy(x => x.Text).ToArray();
+        foreach (var completion in newData)
           data.Add(completion);
 
@@ -77 +87 @@
       }
     }
+
+    protected virtual void DoBackgroundParsing() {
+      while (!codeEditor.IsDisposed) {
+        DoParseStep();
+        Thread.Sleep(1000);
+      }
+    }
   }
 }

branches/CodeEditor/HeuristicLab.CodeEditor/3.4/LanguageFeatures/Interfaces/ICodeCompletionStrategy.cs

@@ -23 +23 @@
   internal interface ICodeCompletionStrategy {
     void DoCodeCompletion(bool controlSpace);
+    void RunBackgroundParser();
   }
 }

branches/CodeEditor/HeuristicLab.CodeEditor/3.4/LanguageFeatures/LanguageFeatures.cs

@@ -56 +56 @@
     #region CodeCompletionStrategy
     protected virtual void AddCodeComplectionStrategy() {
+      codeEditor.Load += LoadedHandler;
       codeEditor.TextEditor.TextArea.TextEntered += CodeCompletionHandler;
       codeEditor.TextEditor.TextArea.TextEntering += InsertionRequestedHandler;
       codeEditor.TextEditor.CommandBindings.Add(commandBinding);
+    }
+
+    private void LoadedHandler(object sender, EventArgs e) {
+      codeCompletionStrategy.RunBackgroundParser();
     }