static int GetIndex(string text)
{
var editorText = new StringBuilder();
int trigger = 0, end = 0;
for (int i = 0; i < text.Length; i++)
{
if (text[i] == '@')
{
trigger = editorText.Length;
continue;
}
if (text[i] == '$')
{
end = editorText.Length;
continue;
}
editorText.Append(text [i]);
}
var doc = new ReadOnlyDocument(editorText.ToString());
var pctx = new CSharpProjectContent();
var rctx = new CSharpTypeResolveContext(pctx.CreateCompilation().MainAssembly);
var ctxProvider = new DefaultCompletionContextProvider(doc, new CSharpUnresolvedFile());
var engine = new CSharpParameterCompletionEngine(doc, ctxProvider, new ParameterCompletionTests.TestFactory(pctx), pctx, rctx);
return(engine.GetCurrentParameterIndex(trigger, end));
}
internal static IParameterDataProvider CreateProvider(string text)
{
string parsedText;
string editorText;
int cursorPosition = text.IndexOf('$');
int endPos = text.IndexOf('$', cursorPosition + 1);
if (endPos == -1)
{
parsedText = editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1);
}
else
{
parsedText = text.Substring(0, cursorPosition) + new string(' ', endPos - cursorPosition) + text.Substring(endPos + 1);
editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring(endPos + 1);
cursorPosition = endPos - 1;
}
var doc = new ReadOnlyDocument(editorText);
IProjectContent pctx = new CSharpProjectContent();
pctx = pctx.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
syntaxTree.Freeze();
var unresolvedFile = syntaxTree.ToTypeSystem();
pctx = pctx.AddOrUpdateFiles(unresolvedFile);
var cmp = pctx.CreateCompilation();
var loc = doc.GetLocation(cursorPosition);
var rctx = new CSharpTypeResolveContext(cmp.MainAssembly);
rctx = rctx.WithUsingScope(unresolvedFile.GetUsingScope(loc).Resolve(cmp));
var curDef = unresolvedFile.GetInnermostTypeDefinition(loc);
if (curDef != null)
{
rctx = rctx.WithCurrentTypeDefinition(curDef.Resolve(rctx).GetDefinition());
var curMember = unresolvedFile.GetMember(loc);
if (curMember != null)
{
rctx = rctx.WithCurrentMember(curMember.CreateResolved(rctx));
}
}
var mb = new DefaultCompletionContextProvider(doc, unresolvedFile);
var engine = new CSharpParameterCompletionEngine(doc, mb, new TestFactory(pctx), pctx, rctx);
return(engine.GetParameterDataProvider(cursorPosition, doc.GetCharAt(cursorPosition - 1)));
}
public IEnumerable <CompletionData> CreateProvider(AutoCompleteRequest request)
{
request.Column = request.Column - request.WordToComplete.Length;
var completionContext = new BufferContext(request, _parser);
var partialWord = request.WordToComplete;
var project = _solution.ProjectContainingFile(request.FileName);
var contextProvider = new DefaultCompletionContextProvider(completionContext.Document, completionContext.ParsedContent.UnresolvedFile);
if (project.CompilerSettings != null)
{
var conditionalSymbols = project.CompilerSettings.ConditionalSymbols;
foreach (var symbol in conditionalSymbols)
{
contextProvider.AddSymbol(symbol);
}
}
var instantiating = IsInstantiating(completionContext.NodeCurrentlyUnderCursor);
var engine = new CSharpCompletionEngine(completionContext.Document
, contextProvider
, new CompletionDataFactory(project
, partialWord
, instantiating
, request
, _config)
, completionContext.ParsedContent.ProjectContent
, completionContext.ResolveContext)
{
EolMarker = Environment.NewLine
};
engine.AutomaticallyAddImports = request.WantImportableTypes;
_logger.Debug("Getting Completion Data");
IEnumerable <CompletionData> data = engine.GetCompletionData(completionContext.CursorPosition, request.ForceSemanticCompletion.GetValueOrDefault(true)).Cast <CompletionData>();
_logger.Debug("Got Completion Data");
return(data.Where(d => d != null && d.CompletionText.IsValidCompletionFor(partialWord))
.FlattenOverloads()
.RemoveDupes()
.OrderByDescending(d => d.RequiredNamespaceImport != null ? 0 : 1)
.ThenByDescending(d => d.CompletionText.IsValidCompletionStartsWithExactCase(partialWord))
.ThenByDescending(d => d.CompletionText.IsValidCompletionStartsWithIgnoreCase(partialWord))
.ThenByDescending(d => d.CompletionText.IsCamelCaseMatch(partialWord))
.ThenByDescending(d => d.CompletionText.IsSubsequenceMatch(partialWord))
.ThenBy(d => d.CompletionText));
}
IEnumerable <Common.ICompletionData> GetCSharpCompletionData(ReadOnlyDocument doc, string editorText, int offset, string fileName, bool isControlSpace = true) // not the best way to put in the whole string every time
{
if (editorText[offset] != '.') //we may be at the partially complete word
{
for (int i = offset - 1; i >= 0; i--)
{
if (SimpleCodeCompletion.Delimiters.Contains(editorText[i]))
{
offset = i + 1;
break;
}
}
}
//test for C# completion
var location = doc.GetLocation(offset);
var syntaxTree = new CSharpParser().Parse(editorText, fileName);
syntaxTree.Freeze();
var unresolvedFile = syntaxTree.ToTypeSystem();
Project = Project.AddOrUpdateFiles(unresolvedFile);
//note project should be reassigned/recreated every time we add asms or file
//IProjectContent project = new CSharpProjectContent();
//project = project.AddAssemblyReferences(builtInLibs.Value);
//project = project.AddOrUpdateFiles(unresolvedFile);
//IProjectContent project = new CSharpProjectContent().AddAssemblyReferences(builtInLibs.Value).AddOrUpdateFiles(unresolvedFile);
var completionContextProvider = new DefaultCompletionContextProvider(doc, unresolvedFile);
var compilation = Project.CreateCompilation();
var resolver = unresolvedFile.GetResolver(compilation, location);
var engine = new CSharpCompletionEngine(doc,
completionContextProvider,
new SimpleCompletionDataFactory(resolver),
Project,
resolver.CurrentTypeResolveContext);
var data = engine.GetCompletionData(offset, isControlSpace);
return(data.PrepareForDisplay().ToCommon());
}
public IEnumerable <ICompletionData> CreateProvider(AutoCompleteRequest request)
{
request.Column = request.Column - request.WordToComplete.Length;
var completionContext = new BufferContext(request, _parser);
var partialWord = request.WordToComplete;
var project = _solution.ProjectContainingFile(request.FileName);
ICompletionContextProvider contextProvider = new DefaultCompletionContextProvider
(completionContext.Document, completionContext.ParsedContent.UnresolvedFile);
var instantiating = IsInstantiating(completionContext.NodeCurrentlyUnderCursor);
var engine = new CSharpCompletionEngine
(completionContext.Document
, contextProvider
, new CompletionDataFactory
(project
, partialWord
, instantiating
, request.WantDocumentationForEveryCompletionResult)
, completionContext.ParsedContent.ProjectContent
, completionContext.ResolveContext)
{
EolMarker = Environment.NewLine
};
_logger.Debug("Getting Completion Data");
IEnumerable <ICompletionData> data = engine.GetCompletionData(completionContext.CursorPosition, true);
_logger.Debug("Got Completion Data");
return(data.Where(d => d != null && d.CompletionText.IsValidCompletionFor(partialWord))
.FlattenOverloads()
.RemoveDupes()
.OrderByDescending(d => d.CompletionText.IsValidCompletionStartsWithExactCase(partialWord))
.ThenByDescending(d => d.CompletionText.IsValidCompletionStartsWithIgnoreCase(partialWord))
.ThenByDescending(d => d.CompletionText.IsCamelCaseMatch(partialWord))
.ThenByDescending(d => d.CompletionText.IsSubsequenceMatch(partialWord))
.ThenBy(d => d.CompletionText));
}
public IEnumerable <ICompletionData> CreateProvider(AutoCompleteRequest request)
{
var editorText = request.Buffer ?? string.Empty;
var filename = request.FileName;
var partialWord = request.WordToComplete ?? string.Empty;
var doc = new ReadOnlyDocument(editorText);
var loc = new TextLocation(request.Line, request.Column - partialWord.Length);
int cursorPosition = doc.GetOffset(loc);
//Ensure cursorPosition only equals 0 when editorText is empty, so line 1,column 1
//completion will work correctly.
cursorPosition = Math.Max(cursorPosition, 1);
cursorPosition = Math.Min(cursorPosition, editorText.Length);
var res = _parser.ParsedContent(editorText, filename);
var rctx = res.UnresolvedFile.GetTypeResolveContext(res.Compilation, loc);
ICompletionContextProvider contextProvider = new DefaultCompletionContextProvider(doc, res.UnresolvedFile);
var engine = new CSharpCompletionEngine(doc, contextProvider, new CompletionDataFactory(partialWord), res.ProjectContent, rctx)
{
EolMarker = Environment.NewLine
};
_logger.Debug("Getting Completion Data");
IEnumerable <ICompletionData> data = engine.GetCompletionData(cursorPosition, true);
_logger.Debug("Got Completion Data");
return(data.Where(d => d != null && d.CompletionText.IsValidCompletionFor(partialWord))
.FlattenOverloads()
.RemoveDupes()
.OrderByDescending(d => d.CompletionText.IsValidCompletionStartsWithExactCase(partialWord))
.ThenByDescending(d => d.CompletionText.IsValidCompletionStartsWithIgnoreCase(partialWord))
.ThenByDescending(d => d.CompletionText.IsCamelCaseMatch(partialWord))
.ThenByDescending(d => d.CompletionText.IsSubsequenceMatch(partialWord))
.ThenBy(d => d.CompletionText));
}
public static IEnumerable <ICompletionData> DoCodeComplete(string editorText, int offset) // not the best way to put in the whole string every time
{
var doc = new ReadOnlyDocument(editorText);
var location = doc.GetLocation(offset);
string parsedText = editorText; // TODO: Why are there different values in test cases?
var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
syntaxTree.Freeze();
var unresolvedFile = syntaxTree.ToTypeSystem();
var mb = new DefaultCompletionContextProvider(doc, unresolvedFile);
IProjectContent pctx = new CSharpProjectContent();
var refs = new List <IUnresolvedAssembly> {
mscorlib.Value, systemCore.Value, systemAssembly.Value
};
pctx = pctx.AddAssemblyReferences(refs);
pctx = pctx.AddOrUpdateFiles(unresolvedFile);
var cmp = pctx.CreateCompilation();
var resolver3 = unresolvedFile.GetResolver(cmp, location);
var engine = new CSharpCompletionEngine(doc, mb, new TestCompletionDataFactory(resolver3), pctx, resolver3.CurrentTypeResolveContext);
engine.EolMarker = Environment.NewLine;
engine.FormattingPolicy = FormattingOptionsFactory.CreateMono();
var data = engine.GetCompletionData(offset, controlSpace: false);
return(data);
}
// i'm not using this...
public static CSharpCompletionEngine CreateEngine(string text, out int cursorPosition, params IUnresolvedAssembly[] references)
{
string parsedText;
string editorText;
cursorPosition = text.IndexOf('$');
int endPos = text.IndexOf('$', cursorPosition + 1);
if (endPos == -1)
{
if (cursorPosition < 0)
{
parsedText = editorText = text;
}
else
{
parsedText = editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1);
}
}
else
{
parsedText = text.Substring(0, cursorPosition) + new string(' ', endPos - cursorPosition) + text.Substring(endPos + 1);
editorText = text.Substring(0, cursorPosition) + text.Substring(cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring(endPos + 1);
cursorPosition = endPos - 1;
}
var doc = new ReadOnlyDocument(editorText);
IProjectContent projContent = new CSharpProjectContent();
var refs = new List <IUnresolvedAssembly> {
mscorlib.Value, systemCore.Value, systemAssembly.Value, systemXmlLinq.Value
};
if (references != null)
{
refs.AddRange(references);
}
projContent = projContent.AddAssemblyReferences(refs);
// Parse => SyntaxTree
var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
syntaxTree.Freeze();
var unresolvedFile = syntaxTree.ToTypeSystem();
// Add CSharpUnresolvedFile to CSharpProjectContent
projContent = projContent.AddOrUpdateFiles(unresolvedFile);
// Create a TypeSystem.ICompilation that allows resolving within the project.
var compilation = projContent.CreateCompilation();
var textCursorLocation = cursorPosition > 0 ? doc.GetLocation(cursorPosition) : new TextLocation(1, 1);
#region Create and Refine the type resolution context as much as possible
var typeResolveContext = new CSharpTypeResolveContext(compilation.MainAssembly);
typeResolveContext = typeResolveContext.WithUsingScope(unresolvedFile.GetUsingScope(textCursorLocation).Resolve(compilation));
var curDef = 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
// Cool! Marry the concept of content & typed
var completionContext = new DefaultCompletionContextProvider(doc, unresolvedFile);
#region Add Preprocessor Symbols
completionContext.AddSymbol("TEST");
foreach (var sym in syntaxTree.ConditionalSymbols)
{
completionContext.AddSymbol(sym);
}
#endregion
var engine = new CSharpCompletionEngine(doc, completionContext, new TestCompletionDataFactory(new CSharpResolver(typeResolveContext)), projContent, typeResolveContext);
engine.EolMarker = Environment.NewLine;
engine.FormattingPolicy = FormattingOptionsFactory.CreateMono();
return(engine);
}
//// 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);
}
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);
}