internal static string GetSignatureHelp(string scriptFile, int caret)
{
Output.WriteLine("GetSignatureHelp");
var script = new SourceInfo(scriptFile);
string result = null;
if (script.Content.IsEmpty())
{
throw new Exception("The file containing code is empty");
}
if (!script.RawFile.EndsWith(".g.cs"))
{
CSScriptHelper.DecorateIfRequired(ref script.Content, ref caret);
}
Project project = CSScriptHelper.GenerateProjectFor(script);
var sources = project.Files
.Where(f => f != project.Script)
.Select(f => new Tuple <string, string>(File.ReadAllText(f), f))
.ToArray();
string bestMatchIndex;
var items = Autocompleter.GetMethodSignatures(script.Content, caret, out bestMatchIndex, project.Refs, sources);
result = $"{bestMatchIndex}\r\n" + items.Select(x => x.EscapeLB())
.JoinSerializedLines();
return(result);
}
private async Task StartReadingDataFromClient(TcpClient acceptedClient)
{
try
{
IPEndPoint ipEndPoint = (IPEndPoint)acceptedClient.Client.RemoteEndPoint;
while (true)
{
MemoryStream bufferStream = new MemoryStream();
byte[] buffer = new byte[1024];
int packetSize = await acceptedClient.GetStream().ReadAsync(buffer, 0, buffer.Length);
if (packetSize == 0)
{
break;
}
Autocompleter completer = new Autocompleter();
// TODO : check correct command here
string word = Encoding.ASCII.GetString(buffer, 0, packetSize).Split(' ')[1];
List <Completion> completions = completer.GetCompletions(word);
string json = JsonSerializer.Serialize(from item in completions select item.Word);
acceptedClient.GetStream().Write(Encoding.Default.GetBytes(json));
}
}
catch (Exception) { }
finally
{
acceptedClient.Close();
Clients.Remove(acceptedClient);
}
}
public static CodeMapItem[] GetMapOf(string code, bool stripInjectedClass = false)
{
bool injected = DecorateIfRequired(ref code);
CodeMapItem[] map = Autocompleter.GetMapOf(code, injected);
if (injected && map.Any())
{
var lines = code.Split("\n".ToCharArray(), map.Last().Line + 5) // +5 to ensure the current line is in
.Select(x => x.Trim())
.ToArray();
var injectionMarker = "///CS-Script auto-class generation";
var debugSymbol = "#line ";
map = map.Where(i => !lines[i.Line - 1].EndsWith(injectionMarker)).ToArray();
foreach (CodeMapItem item in map)
{
var injectedLinesAbove = lines.Take(item.Line - 1)
.Count(x => x.EndsWith(injectionMarker) ||
x.StartsWith(debugSymbol));
item.Line -= injectedLinesAbove;
}
}
return(map);
}
public void Autocomplete()
{
if (LifeCycle.Stage == Stage.Active)
{
Autocompleter.Complete(Data);
}
}
internal static string FindUsings(string scriptFile, string word, bool rich_serialization)
{
Output.WriteLine("FindUsings");
var script = new SourceInfo(scriptFile);
if (script.Content.IsEmpty())
{
throw new Exception("The file containing code is empty");
}
Project project = CSScriptHelper.GenerateProjectFor(script);
var sources = project.Files
.Where(f => f != project.Script)
.Select(f => new Tuple <string, string>(File.ReadAllText(f), f));
var regions = Autocompleter.GetNamespacesFor(script.Content, word, project.Refs, sources);
fullyLoaded = true;
if (rich_serialization)
{
return(regions.Select(Intellisense.Common.TypeInfo.Serialize).JoinSerializedLines());
}
else
{
return(regions.Select(x => x.Namespace).JoinBy("\n"));
}
}
internal static DomRegion ResolveRaw(string scriptFile, int offset)
{
var script = new SourceInfo(scriptFile);
if (script.Content.IsEmpty())
{
throw new Exception("The file containing code is empty");
}
DomRegion region = DomRegion.Empty;
ParseAsCssDirective(script.Content, offset,
directive =>
{
region = CssSyntax.Resolve(directive);
},
(directive, arg, extensions) =>
{
if (LookopDirectivePath(script, offset, directive, arg) is string file)
{
region = new DomRegion
{
BeginColumn = -1,
BeginLine = -1,
EndLine = -1,
FileName = file,
IsEmpty = false
}
}
;
else
{
region = CssSyntax.Resolve(directive);
}
});
if (region.IsEmpty)
{
bool decorated = false;
if (!script.RawFile.EndsWith(".g.cs"))
{
decorated = CSScriptHelper.DecorateIfRequired(ref script.Content, ref offset);
}
Project project = CSScriptHelper.GenerateProjectFor(script);
var sources = project.Files
.Where(f => f != project.Script)
.Select(f => new Tuple <string, string>(File.ReadAllText(f), f))
.ToArray();
region = Autocompleter.ResolveSymbol(script.Content, offset, script.File, project.Refs, sources);
if (decorated && region.FileName == script.File)
{
CSScriptHelper.Undecorate(script.Content, ref region);
}
}
return(region);
}
public static ISymbol LoadCode(string code, params string[] refs)
{
int position = code.IndexOf("|") - 1;
code = code.Replace("|", "");
var doc = Autocompleter.WithWorkspace(code, refs.Concat(new[] { typeof(RoslynHost).Assembly.Location }).ToArray());
ISymbol symbol = SymbolFinder.FindSymbolAtPositionAsync(doc, position).Result;
return(symbol);
}
private void AutocompleteForm_Load(object sender, EventArgs e)
{
string filename = "..\\..\\..\\words.txt";
if (!File.Exists(filename))
{
MessageBox.Show(
string.Format(
"Не найден файл со словарем {0}\r\nВозможно вы забыли распаковать файл words.zip",
Path.GetFullPath(filename)),
"Ошибка");
Environment.Exit(1);
}
autocompleter = new Autocompleter(File.ReadAllLines(filename));
}
internal static string FindRefreneces(string scriptFile, int offset, string context)
{
Output.WriteLine("FindRefreneces");
var script = new SourceInfo(scriptFile);
if (script.Content.IsEmpty())
{
throw new Exception("The file containing code is empty");
}
bool decorated = false;
if (!script.RawFile.EndsWith(".g.cs"))
{
decorated = CSScriptHelper.DecorateIfRequired(ref script.Content, ref offset);
}
Project project = CSScriptHelper.GenerateProjectFor(script);
var sources = project.Files
.Where(f => f != project.Script)
.Select(f => new Tuple <string, string>(File.ReadAllText(f), f))
.ToArray();
var regions = new List <string>();
if (context == "all") // include definition and constructors
{
DomRegion[] refs = Autocompleter.GetSymbolSourceRefs(script.Content, offset, script.File, project.Refs, sources);
foreach (DomRegion item in refs)
{
DomRegion region = item;
if (decorated && item.FileName == script.File)
{
CSScriptHelper.Undecorate(script.Content, ref region);
}
regions.Add($"{item.FileName}({region.BeginLine},{item.BeginColumn}): ...");
}
}
regions.AddRange(Autocompleter.FindReferences(script.Content, offset, script.File, project.Refs, sources));
fullyLoaded = true;
return(regions.Distinct().JoinBy("\n"));
}
void NewTweet_Loaded(object sender, RoutedEventArgs e)
{
string RemoveBack;
if (NavigationContext.QueryString.TryGetValue("removeBack", out RemoveBack) || RemoveBack == "1")
{
NavigationService.RemoveBackEntry();
}
if (ListAccounts.SelectedItems != null)
{
if (DataTransfer.Draft != null && DataTransfer.Draft.Accounts != null)
{
foreach (var account in DataTransfer.Draft.Accounts.Where(x => x != null))
{
ListAccounts.SelectedItems.Add(account);
}
}
else
{
if (!ListAccounts.SelectedItems.Contains(DataTransfer.CurrentAccount))
{
ListAccounts.SelectedItems.Add(DataTransfer.CurrentAccount);
}
}
}
_completer = new Autocompleter();
_completer.User = DataTransfer.CurrentAccount;
_completer.Textbox = TweetBox;
_completer.Trigger = '@';
viewModel.Completer = _completer;
// Update the UI.
if (viewModel.IsGeotagged)
{
Dispatcher.InvokeIfRequired(EnableGeoloc.Begin);
}
else
{
Dispatcher.InvokeIfRequired(DisableGeoloc.Begin);
}
}
public void Initialize()
{
var ctx = new Bunit.TestContext();
cut = ctx.RenderComponent <Autocompleter <Car> >(parameters =>
{
parameters.Add(x => x.Data, new List <Car>
{
new Car {
Id = 4, Make = "Opel", Model = "Astra"
},
new Car {
Id = 8, Make = "Ferrari", Model = "Testarossa"
},
new Car {
Id = 15, Make = "Bugati", Model = "Veyron"
}
});
});
sut = cut.Instance;
}
internal static string GetTooltip(string scriptFile, int caret, string hint, bool shortHintedTooltips)
{
// Simplified API for ST3
Output.WriteLine("GetTooltip");
//Console.WriteLine("hint: " + hint);
string result = null;
var script = new SourceInfo(scriptFile);
if (script.Content.IsEmpty())
{
throw new Exception("The file containing code is empty");
}
void loockupDirective(string directive)
{
var css_directive = CssCompletionData.AllDirectives
.FirstOrDefault(x => x.DisplayText == directive);
if (css_directive != null)
{
result = $"Directive: {css_directive.DisplayText}\n{css_directive.Description}";
result = result.NormalizeLineEnding().Replace("\r\n\r\n", "\r\n").TrimEnd();
}
};
ParseAsCssDirective(script.Content, caret,
loockupDirective,
(directive, arg, extensions) =>
{
if (LookopDirectivePath(script, caret, directive, arg) is string file)
{
result = $"File: {file}";
}
else
{
loockupDirective(directive);
}
});
if (result.HasText())
{
return(result);
}
if (!script.RawFile.EndsWith(".g.cs"))
{
CSScriptHelper.DecorateIfRequired(ref script.Content, ref caret);
}
Project project = CSScriptHelper.GenerateProjectFor(script);
var sources = project.Files
.Where(f => f != project.Script)
.Select(f => new Tuple <string, string>(File.ReadAllText(f), f))
.ToArray();
int methodStartPosTemp;
var items = Autocompleter.GetMemberInfo(script.Content, caret, out methodStartPosTemp, project.Refs, sources, includeOverloads: hint.HasAny());
fullyLoaded = true;
if (hint.HasAny())
{
if (shortHintedTooltips)
{
items = items.Select(x => x.Split('\n').FirstOrDefault()).ToArray();
}
int count = hint.Split(',').Count();
result = items.FirstOrDefault(x =>
{
return(SyntaxMapper.GetArgumentCount(x) == count);
})
?? items.FirstOrDefault();
bool hideOverloadsSummary = false;
if (result != null && hideOverloadsSummary)
{
var lines = result.Split('\n').Select(x => x.TrimEnd('\r')).ToArray();
//(+ 1 overloads)
if (lines[0].EndsWith(" overloads)"))
{
try
{
lines[0] = lines[0].Split(new[] { "(+" }, StringSplitOptions.None).First().Trim();
}
catch { }
}
result = lines.JoinBy("\n");
}
}
else
{
result = items.FirstOrDefault();
}
if (result.HasText())
{
result = result.NormalizeLineEnding().Replace("\r\n\r\n", "\r\n").TrimEnd();
}
return(result);
}
static public string ProcessRequest(Args args)
{
try
{
if (args.script.HasText() && Path.GetExtension(args.script).ToLower() == ".vb")
{
Autocompleter.Language = "VB";
}
if (args.popen.HasText())
{
string[] parts = args.popen.Split('|').ToArray();
string exe = parts.FirstOrDefault();
if (parts.Count() == 2)
{
Process.Start(parts.First(), parts.Last());
}
else if (parts.Count() == 1)
{
Process.Start(parts.First());
}
else
{
return("<error>Invalid 'popen' arguments. Must be <exe>[|<args>]");
}
return(null);
}
if (args.pkill)
{
PKill(args.pid, args.pname);
return(null);
}
if (args.cscs_path != null)
{
if (csscript.cscs_path != args.cscs_path)
{
csscript.cscs_path = Path.GetFullPath(args.cscs_path);
Output.WriteLine(" >> cscs.exe is remapped to: " + csscript.cscs_path);
}
return(null);
}
if (args.op == "ping")
{
try
{
Autocompleter.Load();
return("ready");
}
catch
{
return("not ready");
}
}
string result = "";
if (args.op.HasText())
{
if (!File.Exists(args.script))
{
if (args.script.HasText())
{
return($"<error>File '{args.script}' doesn't exist");
}
else
{
return(null);
}
}
if (args.op == "references")
{
result = FindRefreneces(args.script, args.pos, args.context);
}
else if (args.op.StartsWith("suggest_usings:"))
{
result = FindUsings(args.script, args.op.Split(':').Last(), args.rich);
}
else if (args.op == "resolve")
{
result = Resolve(args.script, args.pos, args.rich);
}
else if (args.op == "completion")
{
result = GetCompletion(args.script, args.pos, args.doc);
}
else if (args.op.StartsWith("tooltip:"))
{
result = GetTooltip(args.script, args.pos, args.op.Split(':').Last(), args.short_hinted_tooltips == 1);
}
else if (args.op.StartsWith("memberinfo"))
{
result = GetMemberInfo(args.script, args.pos, args.collapseOverloads);
}
else if (args.op.StartsWith("signaturehelp"))
{
result = GetSignatureHelp(args.script, args.pos);
}
else if (args.op == "project")
{
result = GenerateProjectFor(args.script);
}
else if (args.op == "codemap")
{
result = CodeMap(args.script, args.rich, false);
}
else if (args.op == "codemap_vscode")
{
result = CodeMap(args.script, args.rich, vsCodeSerialization: true);
}
else if (args.op == "format")
{
Output.WriteLine("FormatCode>");
int caretPos = args.pos;
var formattedCode = FormatCode(args.script, ref caretPos);
Output.WriteLine("<FormatCode");
result = $"{caretPos}\n{formattedCode}";
}
}
if (string.IsNullOrEmpty(result))
{
return("<null>");
}
else
{
return(result);
}
}
catch (Exception e)
{
return("<error>" + e);
}
finally
{
Autocompleter.Language = "C#";
}
}
internal static IEnumerable <ICompletionData> GetCompletionRaw(string scriptFile, int caret, bool includDocumentation = false)
{
var script = new SourceInfo(scriptFile);
if (script.Content.IsEmpty())
{
throw new Exception("The file containing code is empty");
}
IEnumerable <ICompletionData> completions = null;
bool wasHandled = ParseAsCssDirective(script.Content, caret,
(directive) =>
{
completions = CssCompletionData.AllDirectives;
},
(directive, arg, extensions) =>
{
if (directive.OneOf("//css_ac", "//css_autoclass"))
{
completions = new[]
{
new CssCompletionData
{
CompletionText = "freestyle",
DisplayText = "freestyle",
Description = "Free style code without any entry point.",
CompletionType = CompletionType.directive
}
};
}
else
{
completions = LookupDirectivePaths(script, caret, directive, arg, extensions)
.Select(file => new CssCompletionData
{
CompletionText = Path.GetFileName(file),
DisplayText = Path.GetFileName(file),
Description = "File: " + file,
CompletionType = CompletionType.file
});
}
},
ignoreEmptyArgs: false);
if (!wasHandled)
{
if (!script.RawFile.EndsWith(".g.cs"))
{
CSScriptHelper.DecorateIfRequired(ref script.Content, ref caret);
}
Project project = CSScriptHelper.GenerateProjectFor(script);
var sources = project.Files
.Where(f => f != project.Script)
.Select(f => new Tuple <string, string>(File.ReadAllText(f), f))
.ToArray();
completions = Autocompleter.GetAutocompletionFor(script.Content, caret, project.Refs, sources, includDocumentation);
var count = completions.Count();
}
return(completions);
}
public void Remove()
{
Autocompleter completer = new Autocompleter();
completer.Remove();
}
public void Update(string fileName)
{
Autocompleter completer = new Autocompleter();
completer.Update(fileName);
}
internal static string GetMemberInfo(string scriptFile, int caret, bool collapseOverloads)
{
// Complete API for N++
Output.WriteLine("GetMemberInfo");
//Console.WriteLine("hint: " + hint);
var script = new SourceInfo(scriptFile);
string result = null;
if (script.Content.IsEmpty())
{
throw new Exception("The file containing code is empty");
}
void loockupDirective(string directive)
{
var css_directive = CssCompletionData.AllDirectives
.FirstOrDefault(x => x.DisplayText == directive);
if (css_directive != null)
{
result = $"Directive: {css_directive.DisplayText}\n{css_directive.Description}";
result = result.NormalizeLineEnding().Replace("\r\n\r\n", "\r\n").TrimEnd();
}
};
ParseAsCssDirective(script.Content, caret,
loockupDirective,
(directive, arg, extensions) =>
{
if (LookopDirectivePath(script, caret, directive, arg) is string file)
{
result = $"File: {file}";
}
else
{
loockupDirective(directive);
}
});
if (result.HasText())
{
return(MemberInfoData.Serialize(new MemberInfoData {
Info = result
}));
}
if (!script.RawFile.EndsWith(".g.cs"))
{
CSScriptHelper.DecorateIfRequired(ref script.Content, ref caret);
}
Project project = CSScriptHelper.GenerateProjectFor(script);
var sources = project.Files
.Where(f => f != script.File)
.Select(f => new Tuple <string, string>(File.ReadAllText(f), f))
.ToArray();
int methodStartPosTemp;
var items = Autocompleter.GetMemberInfo(script.Content, caret, out methodStartPosTemp, project.Refs, sources, includeOverloads: !collapseOverloads);
if (collapseOverloads)
{
items = items.Take(1);
}
result = items.Select(x => new MemberInfoData {
Info = x, MemberStartPosition = methodStartPosTemp
})
.Select(MemberInfoData.Serialize)
.JoinSerializedLines();
return(result);
}
