| public TryGetCompletionWord ( int offset, int &startPos, int &wordLength ) : bool | ||
| offset | int | |
| startPos | int | |
| wordLength | int | |
| Résultat | bool | |
bool ShowCompletion(ITextEditor editor, char completionChar, bool ctrlSpace)
{
var completionContext = CSharpCompletionContext.Get(editor);
if (completionContext == null)
return false;
var completionFactory = new CSharpCompletionDataFactory(completionContext, new CSharpResolver(completionContext.TypeResolveContextAtCaret));
CSharpCompletionEngine cce = new CSharpCompletionEngine(
editor.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
cce.FormattingPolicy = FormattingOptionsFactory.CreateSharpDevelop();
cce.EolMarker = DocumentUtilities.GetLineTerminator(editor.Document, editor.Caret.Line);
cce.IndentString = editor.Options.IndentationString;
int startPos, triggerWordLength;
IEnumerable<ICompletionData> completionData;
if (ctrlSpace) {
if (!cce.TryGetCompletionWord(editor.Caret.Offset, out startPos, out triggerWordLength)) {
startPos = editor.Caret.Offset;
triggerWordLength = 0;
}
completionData = cce.GetCompletionData(startPos, true);
completionData = completionData.Concat(cce.GetImportCompletionData(startPos));
} else {
startPos = editor.Caret.Offset;
if (char.IsLetterOrDigit (completionChar) || completionChar == '_') {
if (startPos > 1 && char.IsLetterOrDigit (editor.Document.GetCharAt (startPos - 2)))
return false;
completionData = cce.GetCompletionData(startPos, false);
startPos--;
triggerWordLength = 1;
} else {
completionData = cce.GetCompletionData(startPos, false);
triggerWordLength = 0;
}
}
DefaultCompletionItemList list = new DefaultCompletionItemList();
list.Items.AddRange(completionData.Cast<ICompletionItem>());
if (list.Items.Count > 0) {
list.SortItems();
list.PreselectionLength = editor.Caret.Offset - startPos;
list.PostselectionLength = Math.Max(0, startPos + triggerWordLength - editor.Caret.Offset);
list.SuggestedItem = list.Items.FirstOrDefault(i => i.Text == cce.DefaultCompletionString);
editor.ShowCompletionWindow(list);
return true;
}
if (!ctrlSpace) {
// Method Insight
var pce = new CSharpParameterCompletionEngine(
editor.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
var newInsight = pce.GetParameterDataProvider(editor.Caret.Offset, completionChar) as CSharpMethodInsight;
if (newInsight != null && newInsight.items.Count > 0) {
newInsight.UpdateHighlightedParameter(pce);
newInsight.Show();
return true;
}
}
return false;
}
public CodeCompletionResult GetCompletions(IDocument document, int offset, bool controlSpace, string usings, string variables)
{
var result = new CodeCompletionResult();
if (String.IsNullOrEmpty(document.FileName))
return result;
var completionContext = new CSharpCompletionContext(document, offset, projectContent, usings, variables);
var completionFactory = new CSharpCompletionDataFactory(completionContext.TypeResolveContextAtCaret, completionContext);
var cce = new CSharpCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
cce.EolMarker = Environment.NewLine;
cce.FormattingPolicy = FormattingOptionsFactory.CreateSharpDevelop();
var completionChar = completionContext.Document.GetCharAt(completionContext.Offset - 1);
int startPos, triggerWordLength;
IEnumerable<ICSharpCode.NRefactory.Completion.ICompletionData> completionData;
if (controlSpace)
{
if (!cce.TryGetCompletionWord(completionContext.Offset, out startPos, out triggerWordLength))
{
startPos = completionContext.Offset;
triggerWordLength = 0;
}
completionData = cce.GetCompletionData(startPos, true);
//this outputs tons of available entities
//if (triggerWordLength == 0)
// completionData = completionData.Concat(cce.GetImportCompletionData(startPos));
}
else
{
startPos = completionContext.Offset;
if (char.IsLetterOrDigit(completionChar) || completionChar == '_')
{
if (startPos > 1 && char.IsLetterOrDigit(completionContext.Document.GetCharAt(startPos - 2)))
return result;
completionData = cce.GetCompletionData(startPos, false);
startPos--;
triggerWordLength = 1;
}
else
{
completionData = cce.GetCompletionData(startPos, false);
triggerWordLength = 0;
}
}
result.TriggerWordLength = triggerWordLength;
result.TriggerWord = completionContext.Document.GetText(completionContext.Offset - triggerWordLength, triggerWordLength);
Debug.Print("Trigger word: '{0}'", result.TriggerWord);
//cast to AvalonEdit completion data and add to results
foreach (var completion in completionData)
{
var cshellCompletionData = completion as ICSharpCode.CodeCompletion.DataItems.CompletionData;
if (cshellCompletionData != null)
{
cshellCompletionData.TriggerWord = result.TriggerWord;
cshellCompletionData.TriggerWordLength = result.TriggerWordLength;
result.CompletionData.Add(cshellCompletionData);
}
}
//method completions
if (!controlSpace)
{
// Method Insight
var pce = new CSharpParameterCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
var parameterDataProvider = pce.GetParameterDataProvider(completionContext.Offset, completionChar);
result.OverloadProvider = parameterDataProvider as IOverloadProvider;
}
return result;
}
public static ProjectAnalysisResult RunFullProjectAnalysis(ProjectAnalysisRequest projectAnalysisRequest) // ProjectModel projectModel, int fileId, int line, int column)
{
Stopwatch sw = Stopwatch.StartNew();
ProjectAnalysisResult projectAnalysisResult = new ProjectAnalysisResult();
ProjectModel projectModel = projectAnalysisRequest.ProjectModel;
// Set up the project (if not already done)
if (projectModel.ProjectContent == null)
{
projectModel.ProjectContent = new CSharpProjectContent();
projectModel.ProjectContent = projectModel.ProjectContent.AddAssemblyReferences(QCReferences.Value);
}
// For each new file, we need to integrate it into the project content
var fileModelsInProject = projectModel.GetFileDescendants().ToArray();
foreach (var fileModelInProject in fileModelsInProject)
{
IntegrateFileModel(projectModel, fileModelInProject);
}
// We can return now if no code completion was requested
if (projectAnalysisRequest.CodeCompletionParameters == null)
{
projectAnalysisResult.TimeElapsed = sw.Elapsed;
return projectAnalysisResult;
}
// Now it's time to give attention specifically to the matter of resolving the code completion
// options. This, of course, requires a deeper analysis of the specified file...
var codeCompletionParams = projectAnalysisRequest.CodeCompletionParameters;
// Locate the file in the project
ProjectFileModel fileModel = projectModel.FindFile(codeCompletionParams.FileId);
if (fileModel == null)
throw new Exception("Specified file does not exist in this project");
// Create a TypeSystem.ICompilation that allows resolving within the project.
var compilation = projectModel.ProjectContent.CreateCompilation();
#region Resolve text cursor/caret location
// The text cursor position is crucial to creating a properly-scoped type resolution context
// so as to get relevant code completion suggestions.
int textCursorOffset;
TextLocation textCursorLocation;
ReadOnlyDocument doc = new ReadOnlyDocument(fileModel.Content);
if (codeCompletionParams.Line == 0 && codeCompletionParams.Column == 0)
{
textCursorOffset = codeCompletionParams.Offset;
textCursorLocation = doc.GetLocation(textCursorOffset);
codeCompletionParams.Line = textCursorLocation.Line;
codeCompletionParams.Column = textCursorLocation.Column;
}
else
{
textCursorLocation = new TextLocation(codeCompletionParams.Line, codeCompletionParams.Column);
textCursorOffset = doc.GetOffset(textCursorLocation);
codeCompletionParams.Offset = textCursorOffset;
}
#endregion
#region Create and Refine the type resolution context as much as possible based upon the cursor position
var typeResolveContext = new CSharpTypeResolveContext(compilation.MainAssembly);
// Constrain the resolve context by using scope
typeResolveContext = typeResolveContext
.WithUsingScope(fileModel.UnresolvedFile.GetUsingScope(textCursorLocation)
.Resolve(compilation));
var curDef = fileModel.UnresolvedFile.GetInnermostTypeDefinition(textCursorLocation);
if (curDef != null)
{
var resolvedDef = curDef.Resolve(typeResolveContext).GetDefinition();
typeResolveContext = typeResolveContext.WithCurrentTypeDefinition(resolvedDef);
var curMember = resolvedDef.Members.FirstOrDefault(m => m.Region.Begin <= textCursorLocation && textCursorLocation < m.BodyRegion.End);
if (curMember != null)
{
typeResolveContext = typeResolveContext.WithCurrentMember(curMember);
}
}
#endregion
// The purpose of the rest of these steps is a little fuzzy in my mind...
// I'm still trying to understand them fully and if/why they're all needed.
// It seems there is some redundancy here...
var completionContext = new DefaultCompletionContextProvider(doc, fileModel.UnresolvedFile);
#region Add Preprocessor Symbols??
completionContext.AddSymbol("TEST");
foreach (var sym in fileModel.SyntaxTree.ConditionalSymbols)
completionContext.AddSymbol(sym);
#endregion
var completionDataFactory = new TestCompletionDataFactory(new CSharpResolver(typeResolveContext));
var completionEngine = new CSharpCompletionEngine(doc, completionContext, completionDataFactory, projectModel.ProjectContent, typeResolveContext);
completionEngine.EolMarker = Environment.NewLine;
completionEngine.FormattingPolicy = FormattingOptionsFactory.CreateMono();
projectModel.CompletionEngine = completionEngine;
#region Debugging Aid
// Resolve content around text cursor
int numberOfCharactersAroundCursorToResolve = 20;
int firstCharOffset = textCursorOffset - numberOfCharactersAroundCursorToResolve/2;
if (firstCharOffset < 0)
firstCharOffset = 0;
if (doc.TextLength < firstCharOffset+numberOfCharactersAroundCursorToResolve)
numberOfCharactersAroundCursorToResolve = doc.TextLength - firstCharOffset;
string surroundingText = doc.GetText(firstCharOffset, numberOfCharactersAroundCursorToResolve);
Debug.WriteLine("Text around cursor: [{0}]", surroundingText);
#endregion
// Finally, generate completion data!
var completionOptions = completionEngine.GetCompletionData(textCursorOffset, projectAnalysisRequest.CodeCompletionParameters.CtrlSpace).ToArray();
projectAnalysisResult.CompletionOptions = completionEngine.GetCompletionData(textCursorOffset, projectAnalysisRequest.CodeCompletionParameters.CtrlSpace).ToArray();
projectAnalysisResult.AutoCompleteEmptyMatch = completionEngine.AutoCompleteEmptyMatch;
projectAnalysisResult.AutoSelect = completionEngine.AutoSelect;
projectAnalysisResult.DefaultCompletionString = completionEngine.DefaultCompletionString;
int startPos, wordLength;
if (completionEngine.TryGetCompletionWord(textCursorOffset, out startPos, out wordLength))
{
Debug.WriteLine("TryGetCompletionWord :: startpos:{0} wordlength:{1}", startPos, wordLength);
projectAnalysisResult.CompletionWord = doc.GetText(startPos, wordLength);
}
projectAnalysisResult.TimeElapsed = sw.Elapsed;
return projectAnalysisResult;
}
//// todo: eliminate this method later
//private static void AugmentProjectModelWithAlgorithmBase(ProjectModel model)
//{
// model.Children.Add(QcAlgorithmFileModel.Value);
//}
public static ProjectAnalysisResult RunFullProjectAnalysis(ProjectAnalysisRequest projectAnalysisRequest)
{
Stopwatch sw = Stopwatch.StartNew();
ProjectAnalysisResult projectAnalysisResult = new ProjectAnalysisResult();
ProjectModel projectModel = projectAnalysisRequest.ProjectModel;
// todo: Ask Jared why QCAlgorithm is a partial class and why it's not included in "common"
#if false
// ************************************************************************************
// NOTE: In order to get this project building cleanly, with minimal dependencies
// before checking into Github, I've removed all hard QuantConnect dependencies,
// including the QCAlgorithm.cs embedded resource and the assembly references to
// QuantConnect.Algorithm.Interface
// Augment the project model with the QCAgorithm base class
// projectModel.Children.Add(QcAlgorithmFileModel.Value);
// ************************************************************************************
#endif
// Set up the project (if not already done)
if (projectModel.ProjectContent == null)
{
projectModel.ProjectContent = new CSharpProjectContent();
projectModel.ProjectContent = projectModel.ProjectContent.AddAssemblyReferences(QCReferences.Value);
}
// For each new file, we need to integrate it into the project content
var fileModelsInProject = projectModel.GetFileDescendants().ToArray();
foreach (var fileModelInProject in fileModelsInProject)
{
IntegrateFileModel(projectModel, fileModelInProject);
}
// We can return now if no code completion was requested
if (projectAnalysisRequest.CodeCompletionParameters == null)
{
projectAnalysisResult.TimeElapsed = sw.Elapsed;
return projectAnalysisResult;
}
// Now it's time to give attention specifically to the matter of resolving the code completion
// options. This, of course, requires a deeper analysis of the specified file...
var codeCompletionParams = projectAnalysisRequest.CodeCompletionParameters;
// Locate the file in the project
ProjectFileModel fileModel = projectModel.FindFile(codeCompletionParams.FileId);
if (fileModel == null)
throw new Exception("Specified file does not exist in this project");
// Create a TypeSystem.ICompilation that allows resolving within the project.
var compilation = projectModel.ProjectContent.CreateCompilation();
#region Resolve text cursor/caret location
// The text cursor position is crucial to creating a properly-scoped type resolution context
// so as to get relevant code completion suggestions.
int textCursorOffset = 0;
TextLocation textCursorLocation = new TextLocation(1, 1);
ReadOnlyDocument doc = new ReadOnlyDocument(fileModel.Content);
try
{
// if line and column aren't set, we'll assume that the cursor offset/index is set
if (codeCompletionParams.Line == 0 && codeCompletionParams.Column == 0)
{
textCursorOffset = codeCompletionParams.Offset;
if (textCursorOffset < 0) textCursorOffset = 0;
textCursorLocation = doc.GetLocation(textCursorOffset);
}
// if either line or column are invalid (i.e. <= 0), then we'll use offset 0 instead
else if (codeCompletionParams.Line <= 0 || codeCompletionParams.Column <= 0)
{
textCursorOffset = 0;
}
else
{
textCursorLocation = new TextLocation(codeCompletionParams.Line, codeCompletionParams.Column);
textCursorOffset = doc.GetOffset(textCursorLocation);
codeCompletionParams.Offset = textCursorOffset;
}
}
catch (Exception)
{
textCursorOffset = 0;
textCursorLocation = new TextLocation(1, 1);
}
finally
{
projectAnalysisResult.Line = textCursorLocation.Line;
projectAnalysisResult.Column = textCursorLocation.Column;
projectAnalysisResult.Offset = textCursorOffset;
}
#endregion
#region Create and Refine the type resolution context as much as possible based upon the cursor position
var typeResolveContext = new CSharpTypeResolveContext(compilation.MainAssembly);
// Constrain the resolve context by using scope
typeResolveContext = typeResolveContext
.WithUsingScope(fileModel.UnresolvedFile.GetUsingScope(textCursorLocation)
.Resolve(compilation));
var curDef = fileModel.UnresolvedFile.GetInnermostTypeDefinition(textCursorLocation);
if (curDef != null)
{
var resolvedDef = curDef.Resolve(typeResolveContext).GetDefinition();
typeResolveContext = typeResolveContext.WithCurrentTypeDefinition(resolvedDef);
var curMember = resolvedDef.Members.FirstOrDefault(m => m.Region.Begin <= textCursorLocation && textCursorLocation < m.BodyRegion.End);
if (curMember != null)
{
typeResolveContext = typeResolveContext.WithCurrentMember(curMember);
}
}
#endregion
// The purpose of the rest of these steps is a little fuzzy in my mind...
// I'm still trying to understand them fully and if/why they're all needed.
// It seems there is some redundancy here...
var completionContext = new DefaultCompletionContextProvider(doc, fileModel.UnresolvedFile);
#region Add Preprocessor Symbols??
completionContext.AddSymbol("TEST");
foreach (var sym in fileModel.SyntaxTree.ConditionalSymbols)
completionContext.AddSymbol(sym);
#endregion
var completionDataFactory = new CodeCompletionDataFactory(new CSharpResolver(typeResolveContext));
var completionEngine = new CSharpCompletionEngine(doc, completionContext, completionDataFactory, projectModel.ProjectContent, typeResolveContext);
completionEngine.EolMarker = Environment.NewLine;
completionEngine.FormattingPolicy = FormattingOptionsFactory.CreateMono();
projectModel.CompletionEngine = completionEngine;
// Attach contextual info to analysis result
GetDocumentContext(projectAnalysisResult, textCursorOffset, doc);
// Finally, generate completion data!
var completionOptions = completionEngine.GetCompletionData(textCursorOffset, projectAnalysisRequest.CodeCompletionParameters.CtrlSpace).ToArray();
projectAnalysisResult.CompletionOptions = completionOptions.OrderBy(x => x.CompletionText).ToArray();
projectAnalysisResult.AutoCompleteEmptyMatch = completionEngine.AutoCompleteEmptyMatch;
projectAnalysisResult.AutoSelect = completionEngine.AutoSelect;
projectAnalysisResult.DefaultCompletionString = completionEngine.DefaultCompletionString;
int startPos, wordLength;
if (completionEngine.TryGetCompletionWord(textCursorOffset, out startPos, out wordLength))
{
//Debug.WriteLine("TryGetCompletionWord :: startpos:{0} wordlength:{1}", startPos, wordLength);
string completionWord = projectAnalysisResult.CompletionWord = doc.GetText(startPos, wordLength);
if (!string.IsNullOrWhiteSpace(completionWord))
{
var bestMatch = projectAnalysisResult.CompletionOptions
.FirstOrDefault(x => x.CompletionText.CompareTo(completionWord) >= 0);
projectAnalysisResult.BestMatchToCompletionWord = bestMatch;
//if (bestMatch != null)
//projectAnalysisResult.BestMatchToCompletionWord = bestMatch.CompletionText;
}
}
projectAnalysisResult.TimeElapsed = sw.Elapsed;
return projectAnalysisResult;
}
protected override CodeCompletionResult GetCodeCompletionResult(bool controlSpace) {
var document = codeEditor.TextEditor.Document;
int offset = codeEditor.TextEditor.CaretOffset;
var result = new CodeCompletionResult();
try {
var completionContext = new CSharpCodeCompletionContext(document, offset, projectContent);
var completionFactory = new CSharpCodeCompletionDataFactory(completionContext);
var cce = new CSharpCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
char completionChar = completionContext.Document.GetCharAt(completionContext.Offset - 1);
int startPos, triggerWordLength;
IEnumerable<ICompletionData> completionData;
if (controlSpace) {
if (!cce.TryGetCompletionWord(completionContext.Offset, out startPos, out triggerWordLength)) {
startPos = completionContext.Offset;
triggerWordLength = 0;
}
completionData = cce.GetCompletionData(startPos, true);
} else {
startPos = completionContext.Offset;
if (char.IsLetterOrDigit(completionChar) || completionChar == '_') {
if (startPos > 1 && char.IsLetterOrDigit(completionContext.Document.GetCharAt((startPos - 2))))
return result;
completionData = cce.GetCompletionData(startPos, false);
triggerWordLength = 1;
} else {
completionData = cce.GetCompletionData(startPos, false);
triggerWordLength = 0;
}
}
result.TriggerWordLength = triggerWordLength;
result.TriggerWord = completionContext.Document.GetText(completionContext.Offset - triggerWordLength, triggerWordLength);
if (completionData.Any() && cce.AutoCompleteEmptyMatch) {
foreach (var completion in completionData) {
var cast = completion as CompletionData;
if (cast != null) {
cast.TriggerWord = result.TriggerWord;
cast.TriggerWordLength = result.TriggerWordLength;
result.CompletionData.Add(cast);
}
}
}
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;
}
} catch {
// ignore exceptions thrown during code completion
}
return result;
}
bool ShowCompletion(ITextEditor editor, char completionChar, bool ctrlSpace)
{
CSharpCompletionContext completionContext;
if (fileContent == null) {
completionContext = CSharpCompletionContext.Get(editor);
} else {
completionContext = CSharpCompletionContext.Get(editor, context, currentLocation, fileContent);
}
if (completionContext == null)
return false;
int caretOffset;
if (fileContent == null) {
caretOffset = editor.Caret.Offset;
currentLocation = editor.Caret.Location;
} else {
caretOffset = completionContext.Document.GetOffset(currentLocation);
}
var completionFactory = new CSharpCompletionDataFactory(completionContext, new CSharpResolver(completionContext.TypeResolveContextAtCaret));
CSharpCompletionEngine cce = new CSharpCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(completionContext.Compilation.GetProject());
cce.FormattingPolicy = formattingOptions.OptionsContainer.GetEffectiveOptions();
cce.EolMarker = DocumentUtilities.GetLineTerminator(completionContext.Document, currentLocation.Line);
cce.IndentString = editor.Options.IndentationString;
int startPos, triggerWordLength;
IEnumerable<ICompletionData> completionData;
if (ctrlSpace) {
if (!cce.TryGetCompletionWord(caretOffset, out startPos, out triggerWordLength)) {
startPos = caretOffset;
triggerWordLength = 0;
}
completionData = cce.GetCompletionData(startPos, true);
completionData = completionData.Concat(cce.GetImportCompletionData(startPos));
} else {
startPos = caretOffset;
if (char.IsLetterOrDigit (completionChar) || completionChar == '_') {
if (!CodeCompletionOptions.CompleteWhenTyping) return false;
if (startPos > 1 && char.IsLetterOrDigit (completionContext.Document.GetCharAt (startPos - 2)))
return false;
completionData = cce.GetCompletionData(startPos, false);
startPos--;
triggerWordLength = 1;
} else {
completionData = cce.GetCompletionData(startPos, false);
triggerWordLength = 0;
}
}
DefaultCompletionItemList list = new DefaultCompletionItemList();
list.Items.AddRange(FilterAndAddTemplates(editor, completionData.Cast<ICompletionItem>().ToList()));
if (list.Items.Count > 0 && (ctrlSpace || cce.AutoCompleteEmptyMatch)) {
list.SortItems();
list.PreselectionLength = caretOffset - startPos;
list.PostselectionLength = Math.Max(0, startPos + triggerWordLength - caretOffset);
list.SuggestedItem = list.Items.FirstOrDefault(i => i.Text == cce.DefaultCompletionString);
editor.ShowCompletionWindow(list);
return true;
}
if (CodeCompletionOptions.InsightEnabled && !ctrlSpace) {
// Method Insight
var pce = new CSharpParameterCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
var newInsight = pce.GetParameterDataProvider(caretOffset, completionChar) as CSharpMethodInsight;
if (newInsight != null && newInsight.items.Count > 0) {
newInsight.UpdateHighlightedParameter(pce);
newInsight.Show();
return true;
}
}
return false;
}
public CodeCompletionResult GetCompletions(IDocument document, int offset, bool controlSpace, string usings, string variables = null)
{
var result = new CodeCompletionResult();
if (String.IsNullOrEmpty(document.FileName))
return result;
var completionContext = new CSharpCompletionContext(document, offset, projectContent, usings, variables);
var completionFactory = new CSharpCompletionDataFactory(completionContext.TypeResolveContextAtCaret, completionContext);
var cce = new CSharpCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
cce.EolMarker = Environment.NewLine;
cce.FormattingPolicy = FormattingOptionsFactory.CreateSharpDevelop();
var completionChar = completionContext.Document.GetCharAt(completionContext.Offset - 1);
int startPos, triggerWordLength;
IEnumerable<ICSharpCode.NRefactory.Completion.ICompletionData> completionData;
if (controlSpace)
{
if (!cce.TryGetCompletionWord(completionContext.Offset, out startPos, out triggerWordLength))
{
startPos = completionContext.Offset;
triggerWordLength = 0;
}
completionData = cce.GetCompletionData(startPos, true);
//this outputs tons of available entities
//if (triggerWordLength == 0)
// completionData = completionData.Concat(cce.GetImportCompletionData(startPos));
}
else
{
startPos = completionContext.Offset;
if (char.IsLetterOrDigit(completionChar) || completionChar == '_')
{
if (startPos > 1 && char.IsLetterOrDigit(completionContext.Document.GetCharAt(startPos - 2)))
return result;
completionData = cce.GetCompletionData(startPos, false);
startPos--;
triggerWordLength = 1;
}
else
{
completionData = cce.GetCompletionData(startPos, false);
triggerWordLength = 0;
}
}
result.TriggerWordLength = triggerWordLength;
result.TriggerWord = completionContext.Document.GetText(completionContext.Offset - triggerWordLength, triggerWordLength);
Debug.Print("Trigger word: '{0}'", result.TriggerWord);
//cast to AvalonEdit completion data and add to results
foreach (var completion in completionData)
{
var cshellCompletionData = completion as ICSharpCode.CodeCompletion.DataItems.CompletionData;
if (cshellCompletionData != null)
{
cshellCompletionData.TriggerWord = result.TriggerWord;
cshellCompletionData.TriggerWordLength = result.TriggerWordLength;
if (completion is ICSharpCode.CodeCompletion.DataItems.EntityCompletionData)
{
string typename = String.Empty;
var entity = cshellCompletionData as ICSharpCode.CodeCompletion.DataItems.EntityCompletionData;
if (entity.Entity is ICSharpCode.NRefactory.TypeSystem.Implementation.DefaultResolvedTypeDefinition)
{
var def = entity.Entity as ICSharpCode.NRefactory.TypeSystem.Implementation.DefaultResolvedTypeDefinition;
typename = def.FullTypeName.ReflectionName;
}
else
{
typename = entity.Entity.DeclaringType.FullName;
}
Type type = Type.GetType(typename);
if (!AllowedType(type))
{
continue;
}
}
result.CompletionData.Add(cshellCompletionData);
// piggyback 'region' preprocessor to add our own
if (cshellCompletionData.DisplayText == "region")
{
DataItems.CompletionData import = new DataItems.CompletionData("import");
import.CompletionCategory = cshellCompletionData.CompletionCategory;
import.Image = cshellCompletionData.Image;
result.CompletionData.Add(import);
}
}
}
//method completions
if (!controlSpace)
{
// Method Insight
var pce = new CSharpParameterCompletionEngine(
completionContext.Document,
completionContext.CompletionContextProvider,
completionFactory,
completionContext.ProjectContent,
completionContext.TypeResolveContextAtCaret
);
var parameterDataProvider = pce.GetParameterDataProvider(completionContext.Offset, completionChar);
result.OverloadProvider = parameterDataProvider as IOverloadProvider;
}
return result;
}