コード例 #1
0
        public void LintAsync(string[] files, LintCallback callback)
        {
            var context = ASContext.GetLanguageContext("haxe") as Context;

            if (context == null || !CanContinue(context))
            {
                return;
            }

            var total = files.Length;
            var list  = new List <LintingResult>();

            foreach (var file in files)
            {
                ITabbedDocument document;
                if (!File.Exists(file) || (document = DocumentManager.FindDocument(file)) != null && document.IsUntitled)
                {
                    total--;
                    continue;
                }

                var sciCreated = false;
                var sci        = document?.SciControl;
                if (sci == null)
                {
                    sci        = GetStubSci(file);
                    sciCreated = true;
                }

                var hc = context.GetHaxeComplete(sci, new ASExpr {
                    Position = 0
                }, true, HaxeCompilerService.DIAGNOSTICS);

                fileQueue.Run(finished =>
                {
                    hc.GetDiagnostics((complete, results, status) =>
                    {
                        total--;

                        if (sciCreated)
                        {
                            sci.Dispose();
                        }

                        AddDiagnosticsResults(list, status, results, hc);

                        if (total == 0)
                        {
                            callback(list);
                        }

                        finished();
                    });
                });
            }
        }
コード例 #2
0
        public void LintAsync(IEnumerable <string> files, LintCallback callback)
        {
            var context = ASContext.GetLanguageContext("haxe") as Context;

            if (context == null || !(PluginBase.CurrentProject is ProjectManager.Projects.Haxe.HaxeProject) || !CanContinue(context))
            {
                return;
            }

            var total = files.Count();
            var list  = new List <LintingResult>();

            String untitledFileStart = TextHelper.GetString("FlashDevelop.Info.UntitledFileStart");

            foreach (var file in files)
            {
                if (!File.Exists(file) || file.StartsWithOrdinal(untitledFileStart))
                {
                    total--;
                    continue;
                }

                var sci = GetStubSci(file);

                var hc = context.GetHaxeComplete(sci, new ASExpr {
                    Position = 0
                }, true, HaxeCompilerService.DIAGNOSTICS);

                fileQueue.Run(finished =>
                {
                    hc.GetDiagnostics((complete, results, status) =>
                    {
                        total--;

                        sci.Dispose();

                        AddDiagnosticsResults(list, status, results, hc);

                        if (total == 0)
                        {
                            callback(list);
                        }

                        finished();
                    });
                });
            }
        }
コード例 #3
0
        public void LintProjectAsync(IProject project, LintCallback callback)
        {
            var context = ASContext.GetLanguageContext("haxe") as Context;

            if (context == null || !CanContinue(context))
            {
                return;
            }

            var list = new List <LintingResult>();
            var sci  = GetStubSci();
            var hc   = context.GetHaxeComplete(sci, new ASExpr {
                Position = 0
            }, true, HaxeCompilerService.GLOBAL_DIAGNOSTICS);

            hc.GetDiagnostics((complete, results, status) =>
            {
                sci.Dispose();

                AddDiagnosticsResults(list, status, results, hc);

                callback(list);
            });
        }
コード例 #4
0
        public void LintAsync(string[] files, LintCallback callback)
        {
            var context = ASContext.GetLanguageContext("haxe") as Context;

            if (context == null)
            {
                return;
            }
            var completionMode = ((HaXeSettings)context.Settings).CompletionMode;

            if (completionMode == HaxeCompletionModeEnum.FlashDevelop)
            {
                return;
            }
            var haxeVersion = context.GetCurrentSDKVersion();

            if (haxeVersion < "3.3.0")
            {
                return;
            }

            var list     = new List <LintingResult>();
            int progress = 0;
            int total    = files.Length;

            for (var i = 0; i < files.Length; i++)
            {
                var             file = files[i];
                ITabbedDocument document;
                if (!File.Exists(file) || (document = DocumentManager.FindDocument(file)) != null && document.IsUntitled)
                {
                    total--;
                    continue;
                }
                bool sciCreated = false;
                var  sci        = document?.SciControl;
                if (sci == null)
                {
                    sci = new ScintillaControl
                    {
                        FileName = file,
                        ConfigurationLanguage = "haxe"
                    };
                    sciCreated = true;
                }

                var hc = context.GetHaxeComplete(sci, new ASExpr {
                    Position = 0
                }, true, HaxeCompilerService.DIAGNOSTICS);
                hc.GetDiagnostics((complete, results, status) =>
                {
                    progress++;
                    if (sciCreated)
                    {
                        sci.Dispose();
                    }

                    if (status == HaxeCompleteStatus.DIAGNOSTICS && results != null)
                    {
                        foreach (var res in results)
                        {
                            var result = new LintingResult
                            {
                                File      = res.Range.Path,
                                FirstChar = res.Range.CharacterStart,
                                Length    = res.Range.CharacterEnd - res.Range.CharacterStart,
                                Line      = res.Range.LineStart + 1,
                            };

                            switch (res.Severity)
                            {
                            case HaxeDiagnosticsSeverity.INFO:
                                result.Severity = LintingSeverity.Info;
                                break;

                            case HaxeDiagnosticsSeverity.ERROR:
                                result.Severity = LintingSeverity.Error;
                                break;

                            case HaxeDiagnosticsSeverity.WARNING:
                                result.Severity = LintingSeverity.Warning;
                                break;

                            default:
                                continue;
                            }

                            switch (res.Kind)
                            {
                            case HaxeDiagnosticsKind.UnusedImport:
                                result.Description = TextHelper.GetString("Info.UnusedImport");
                                break;

                            case HaxeDiagnosticsKind.UnresolvedIdentifier:
                                result.Description = TextHelper.GetString("Info.UnresolvedIdentifier");
                                break;

                            case HaxeDiagnosticsKind.CompilerError:
                            case HaxeDiagnosticsKind.RemovableCode:
                                result.Description = res.Args.Description;
                                break;

                            default:     //in case new kinds are added in new compiler versions
                                continue;
                            }

                            list.Add(result);
                        }
                    }
                    else if (status == HaxeCompleteStatus.ERROR)
                    {
                        PluginBase.RunAsync(() =>
                        {
                            TraceManager.Add(hc.Errors, (int)TraceType.Error);
                        });
                    }

                    if (progress == total)
                    {
                        callback(list);
                    }
                });
            }
        }