diff options
Diffstat (limited to 'elpa/typescript-mode-20220506.827/typescript-mode.el')
| -rw-r--r-- | elpa/typescript-mode-20220506.827/typescript-mode.el | 2988 |
1 files changed, 0 insertions, 2988 deletions
diff --git a/elpa/typescript-mode-20220506.827/typescript-mode.el b/elpa/typescript-mode-20220506.827/typescript-mode.el deleted file mode 100644 index 220cf75..0000000 --- a/elpa/typescript-mode-20220506.827/typescript-mode.el +++ /dev/null @@ -1,2988 +0,0 @@ -;;; typescript-mode.el --- Major mode for editing typescript - -;; ----------------------------------------------------------------------------------- -;; TypeScript support for Emacs -;; Unmodified original sourve available at http://www.karllandstrom.se/downloads/emacs/javascript.el -;; Copyright (c) 2008 Free Software Foundation -;; Portions Copyright (C) Microsoft Open Technologies, Inc. All rights reserved. -;; -;; This program is free software: you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. -;; -;; This program is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. -;; -;; You should have received a copy of the GNU General Public License -;; along with this program. If not, see <http://www.gnu.org/licenses/>. -;; ------------------------------------------------------------------------------------------- - -;; URL: http://github.com/ananthakumaran/typescript.el -;; Version: 0.4 -;; Keywords: typescript languages -;; Package-Requires: ((emacs "24.3")) - -;; This file is not part of GNU Emacs. - -;;; Commentary: - -;; This is based on Karl Landstrom's barebones typescript-mode. This -;; is much more robust and works with cc-mode's comment filling -;; (mostly). -;; The modifications to the original javascript.el mode mainly consisted in -;; replacing "javascript" with "typescript" -;; -;; The main features of this typescript mode are syntactic -;; highlighting (enabled with `font-lock-mode' or -;; `global-font-lock-mode'), automatic indentation and filling of -;; comments. -;; -;; -;; General Remarks: -;; -;; XXX: This mode assumes that block comments are not nested inside block -;; XXX: comments -;; -;; Exported names start with "typescript-"; private names start with -;; "typescript--". - -;;; Code: - -(eval-and-compile - (require 'compile) - (require 'cc-mode) - (require 'font-lock) - (require 'rx) - (require 'newcomment)) - -(eval-when-compile - (require 'cl-lib)) - -;;; Constants - -(defconst typescript--type-name-re "\\(?:[A-Z][A-Za-z0-9]+\\.\\)\\{0,\\}\\(?:[A-Z][A-Za-z0-9]+\\)" - "Regexp matching a conventional TypeScript type-name. Must start with upper-case letter!") - -(defconst typescript--name-start-re "[a-zA-Z_$]" - "Regexp matching the start of a typescript identifier, without grouping.") - -(defconst typescript--name-re (concat typescript--name-start-re - "\\(?:\\s_\\|\\sw\\)*") - "Regexp matching a typescript identifier, without grouping.") - -(defconst typescript--objfield-re (concat typescript--name-re ":") - "Regexp matching the start of a typescript object field.") - -(defconst typescript--dotted-name-re - (concat typescript--name-re "\\(?:\\." typescript--name-re "\\)*") - "Regexp matching a dot-separated sequence of typescript names.") - -(defconst typescript--plain-method-re - (concat "^\\s-*?\\(" typescript--dotted-name-re "\\)\\.prototype" - "\\.\\(" typescript--name-re "\\)\\s-*?=\\s-*?\\(function\\)\\_>") - "Regexp matching an explicit typescript prototype \"method\" declaration. -Group 1 is a (possibly-dotted) class name, group 2 is a method name, -and group 3 is the 'function' keyword.") - -(defconst typescript--plain-class-re - (concat "^\\s-*\\(" typescript--dotted-name-re "\\)\\.prototype" - "\\s-*=\\s-*{") - "Regexp matching a typescript explicit prototype \"class\" declaration. -An example of this is \"Class.prototype = { method1: ...}\".") - -(defconst typescript--module-declaration-re - "^\\s-*\\(?:declare\\|\\(?:export\\(?:\\s-+default\\)?\\)\\)?" - "Regexp matching ambient declaration modifier or export declaration.") - -;; var NewClass = BaseClass.extend( -(defconst typescript--mp-class-decl-re - (concat "^\\s-*var\\s-+" - "\\(" typescript--name-re "\\)" - "\\s-*=\\s-*" - "\\(" typescript--dotted-name-re - "\\)\\.extend\\(?:Final\\)?\\s-*(\\s-*{?\\s-*$")) - -;; var NewClass = Class.create() -(defconst typescript--prototype-obsolete-class-decl-re - (concat "^\\s-*\\(?:var\\s-+\\)?" - "\\(" typescript--dotted-name-re "\\)" - "\\s-*=\\s-*Class\\.create()")) - -(defconst typescript--prototype-objextend-class-decl-re-1 - (concat "^\\s-*Object\\.extend\\s-*(" - "\\(" typescript--dotted-name-re "\\)" - "\\s-*,\\s-*{")) - -(defconst typescript--prototype-objextend-class-decl-re-2 - (concat "^\\s-*\\(?:var\\s-+\\)?" - "\\(" typescript--dotted-name-re "\\)" - "\\s-*=\\s-*Object\\.extend\\s-*\(")) - -;; var NewClass = Class.create({ -(defconst typescript--prototype-class-decl-re - (concat "^\\s-*\\(?:var\\s-+\\)?" - "\\(" typescript--name-re "\\)" - "\\s-*=\\s-*Class\\.create\\s-*(\\s-*" - "\\(?:\\(" typescript--dotted-name-re "\\)\\s-*,\\s-*\\)?{?")) - -;; Parent class name(s) (yes, multiple inheritance in typescript) are -;; matched with dedicated font-lock matchers -(defconst typescript--dojo-class-decl-re - (concat "^\\s-*dojo\\.declare\\s-*(\"\\(" typescript--dotted-name-re "\\)")) - -(defconst typescript--exttypescript-class-decl-re-1 - (concat "^\\s-*Ext\\.extend\\s-*(" - "\\s-*\\(" typescript--dotted-name-re "\\)" - "\\s-*,\\s-*\\(" typescript--dotted-name-re "\\)") - "Regexp matching an ExtTYPESCRIPT class declaration (style 1).") - -(defconst typescript--exttypescript-class-decl-re-2 - (concat "^\\s-*\\(?:var\\s-+\\)?" - "\\(" typescript--name-re "\\)" - "\\s-*=\\s-*Ext\\.extend\\s-*(\\s-*" - "\\(" typescript--dotted-name-re "\\)") - "Regexp matching an ExtTYPESCRIPT class declaration (style 2).") - -(defconst typescript--mochikit-class-re - (concat "^\\s-*MochiKit\\.Base\\.update\\s-*(\\s-*" - "\\(" typescript--dotted-name-re "\\)") - "Regexp matching a MochiKit class declaration.") - -(defconst typescript--dummy-class-style - '(:name "[Automatically Generated Class]")) - -(defconst typescript--class-styles - `((:name "Plain" - :class-decl ,typescript--plain-class-re - :prototype t - :contexts (toplevel) - :framework typescript) - - (:name "MochiKit" - :class-decl ,typescript--mochikit-class-re - :prototype t - :contexts (toplevel) - :framework mochikit) - - (:name "Prototype (Obsolete)" - :class-decl ,typescript--prototype-obsolete-class-decl-re - :contexts (toplevel) - :framework prototype) - - (:name "Prototype (Modern)" - :class-decl ,typescript--prototype-class-decl-re - :contexts (toplevel) - :framework prototype) - - (:name "Prototype (Object.extend)" - :class-decl ,typescript--prototype-objextend-class-decl-re-1 - :prototype t - :contexts (toplevel) - :framework prototype) - - (:name "Prototype (Object.extend) 2" - :class-decl ,typescript--prototype-objextend-class-decl-re-2 - :prototype t - :contexts (toplevel) - :framework prototype) - - (:name "Dojo" - :class-decl ,typescript--dojo-class-decl-re - :contexts (toplevel) - :framework dojo) - - (:name "ExtTYPESCRIPT (style 1)" - :class-decl ,typescript--exttypescript-class-decl-re-1 - :prototype t - :contexts (toplevel) - :framework exttypescript) - - (:name "ExtTYPESCRIPT (style 2)" - :class-decl ,typescript--exttypescript-class-decl-re-2 - :contexts (toplevel) - :framework exttypescript) - - (:name "Merrill Press" - :class-decl ,typescript--mp-class-decl-re - :contexts (toplevel) - :framework merrillpress)) - - "List of typescript class definition styles. - -A class definition style is a plist with the following keys: - -:name is a human-readable name of the class type - -:class-decl is a regular expression giving the start of the -class. Its first group must match the name of its class. If there -is a parent class, the second group should match, and it should be -the name of the class. - -If :prototype is present and non-nil, the parser will merge -declarations for this constructs with others at the same lexical -level that have the same name. Otherwise, multiple definitions -will create multiple top-level entries. Don't use :prototype -unnecessarily: it has an associated cost in performance. - -If :strip-prototype is present and non-nil, then if the class -name as matched contains") - -(defconst typescript--available-frameworks - (cl-loop with available-frameworks - for style in typescript--class-styles - for framework = (plist-get style :framework) - unless (memq framework available-frameworks) - collect framework into available-frameworks - finally return available-frameworks) - "List of available typescript frameworks symbols.") - -(defconst typescript--function-heading-1-re - (concat - typescript--module-declaration-re - "\\s-*function\\s-+\\(" typescript--name-re "\\)") - "Regexp matching the start of a typescript function header. -Match group 1 is the name of the function.") - -(defconst typescript--function-heading-2-re - (concat - "^\\s-*\\(" typescript--name-re "\\)\\s-*:\\s-*function\\_>") - "Regexp matching the start of a function entry in an associative array. -Match group 1 is the name of the function.") - -(defconst typescript--function-heading-3-re - (concat - "^\\s-*\\(?:var\\s-+\\)?\\(" typescript--dotted-name-re "\\)" - "\\s-*=\\s-*function\\_>") - "Regexp matching a line in the typescript form \"var MUMBLE = function\". -Match group 1 is MUMBLE.") - -(defun typescript--regexp-opt-symbol (list) - "Like `regexp-opt', but surround the result with `\\\\_<' and `\\\\_>'." - (concat "\\_<" (regexp-opt list t) "\\_>")) - -(defconst typescript--keyword-re - (typescript--regexp-opt-symbol - '("abstract" "any" "as" "async" "await" "boolean" "bigint" "break" "case" "catch" "class" "const" - "constructor" "continue" "debugger" "declare" "default" "delete" "do" "else" - "enum" "export" "extends" "extern" "false" "finally" "for" - "function" "from" "get" "goto" "if" "implements" "import" "in" "instanceof" - "interface" "keyof" "let" "module" "namespace" "never" "new" "null" "number" "object" "of" - "override" "private" "protected" "public" "readonly" "return" "set" "static" "string" - "super" "switch" "this" "throw" "true" - "try" "type" "typeof" "unknown" "var" "void" - "while")) ; yield is handled separately - "Regexp matching any typescript keyword.") - -(defconst typescript--basic-type-re - (typescript--regexp-opt-symbol - '("any" "bool" "boolean" "bigint" "never" "number" "string" "unknown" "void")) - "Regular expression matching any predefined type in typescript.") - -(defconst typescript--access-modifier-re - (typescript--regexp-opt-symbol - '("private" "protected" "public" "readonly" "static" "extends" "implements")) - "Regular expression matching access modifiers.") - -(defconst typescript--decorator-re - (concat "\\(@" typescript--name-re "\\)")) - -(defconst typescript--constant-re - (typescript--regexp-opt-symbol '("false" "null" "undefined" - "Infinity" "NaN" - "true" "arguments" "this")) - "Regular expression matching any future reserved words in typescript.") - -(defconst typescript--builtin-re - (typescript--regexp-opt-symbol - '("console")) - "Regular expression matching builtins.") - -(defconst typescript--function-call-re "\\(\\(?:\\w\\|\\s_\\)+\\)\\(<.+>\\)?\s*(" - "Regular expression matching function calls.") - -(defconst typescript--font-lock-keywords-1 - (list - "\\_<import\\_>" - (list typescript--function-heading-1-re 1 font-lock-function-name-face) - (list typescript--function-heading-2-re 1 font-lock-function-name-face)) - "Level one font lock keywords for `typescript-mode'.") - -(defconst typescript--font-lock-keywords-2 - (append typescript--font-lock-keywords-1 - (list (cons typescript--constant-re font-lock-constant-face) - (cons typescript--basic-type-re font-lock-type-face) - (list typescript--keyword-re 1 font-lock-keyword-face) - (list "\\_<for\\_>" - "\\s-+\\(each\\)\\_>" nil nil - (list 1 'font-lock-keyword-face)) - (cons "\\_<yield\\(\\*\\|\\_>\\)" 'font-lock-keyword-face))) - "Level two font lock keywords for `typescript-mode'.") - -;; typescript--pitem is the basic building block of the lexical -;; database. When one refers to a real part of the buffer, the region -;; of text to which it refers is split into a conceptual header and -;; body. Consider the (very short) block described by a hypothetical -;; typescript--pitem: -;; -;; function foo(a,b,c) { return 42; } -;; ^ ^ ^ -;; | | | -;; +- h-begin +- h-end +- b-end -;; -;; (Remember that these are buffer positions, and therefore point -;; between characters, not at them. An arrow drawn to a character -;; indicates the corresponding position is between that character and -;; the one immediately preceding it.) -;; -;; The header is the region of text [h-begin, h-end], and is -;; the text needed to unambiguously recognize the start of the -;; construct. If the entire header is not present, the construct is -;; not recognized at all. No other pitems may be nested inside the -;; header. -;; -;; The body is the region [h-end, b-end]. It may contain nested -;; typescript--pitem instances. The body of a pitem may be empty: in -;; that case, b-end is equal to header-end. -;; -;; The three points obey the following relationship: -;; -;; h-begin < h-end <= b-end -;; -;; We put a text property in the buffer on the character *before* -;; h-end, and if we see it, on the character *before* b-end. -;; -;; The text property for h-end, typescript--pstate, is actually a list -;; of all typescript--pitem instances open after the marked character. -;; -;; The text property for b-end, typescript--pend, is simply the -;; typescript--pitem that ends after the marked character. (Because -;; pitems always end when the paren-depth drops below a critical -;; value, and because we can only drop one level per character, only -;; one pitem may end at a given character.) -;; -;; In the structure below, we only store h-begin and (sometimes) -;; b-end. We can trivially and quickly find h-end by going to h-begin -;; and searching for an typescript--pstate text property. Since no other -;; typescript--pitem instances can be nested inside the header of a -;; pitem, the location after the character with this text property -;; must be h-end. -;; -;; typescript--pitem instances are never modified (with the exception -;; of the b-end field). Instead, modified copies are added at subseqnce parse points. -;; (The exception for b-end and its caveats is described below.) -;; - -(cl-defstruct (typescript--pitem (:type list)) - ;; IMPORTANT: Do not alter the position of fields within the list. - ;; Various bits of code depend on their positions, particularly - ;; anything that manipulates the list of children. - - ;; List of children inside this pitem's body - (children nil :read-only t) - - ;; When we reach this paren depth after h-end, the pitem ends - (paren-depth nil :read-only t) - - ;; Symbol or class-style plist if this is a class - (type nil :read-only t) - - ;; See above - (h-begin nil :read-only t) - - ;; List of strings giving the parts of the name of this pitem (e.g., - ;; '("MyClass" "myMethod"), or t if this pitem is anonymous - (name nil :read-only t) - - ;; THIS FIELD IS MUTATED, and its value is shared by all copies of - ;; this pitem: when we copy-and-modify pitem instances, we share - ;; their tail structures, so all the copies actually have the same - ;; terminating cons cell. We modify that shared cons cell directly. - ;; - ;; The field value is either a number (buffer location) or nil if - ;; unknown. - ;; - ;; If the field's value is greater than `typescript--cache-end', the - ;; value is stale and must be treated as if it were nil. Conversely, - ;; if this field is nil, it is guaranteed that this pitem is open up - ;; to at least `typescript--cache-end'. (This property is handy when - ;; computing whether we're inside a given pitem.) - ;; - (b-end nil)) - -;; The pitem we start parsing with. -(defconst typescript--initial-pitem - (make-typescript--pitem - :paren-depth most-negative-fixnum - :type 'toplevel)) - -;; When we say "jsdoc" here, we mean "jsdoc 3". There exist multiple dialects of -;; "jsdoc documentation". - -;; Note that all typedoc/jsdoc regexp by themselves would match occurrences that appear outside -;; documentation comments. The logic that uses these regexps must guard against it. -(defconst typescript-typedoc-link-tag-regexp - "\\[\\[.*?\\]\\]" - "Matches a typedoc link.") - -(defconst typescript-typedoc-literal-markup-regexp - "\\(`+\\).*?\\1" - "Matches a typedoc keyword markup.") - -(defconst typescript-jsdoc-before-tag-regexp - "\\(?:^\\s-*\\*+\\|/\\*\\*\\)\\s-*" - "Matches everything we allow before the @ of a jsdoc tag.") - -;; This was taken from js2-mode. -(defconst typescript-jsdoc-param-tag-regexp - (concat typescript-jsdoc-before-tag-regexp - "\\(@" - (regexp-opt - '("arg" - "argument" - "param" - "prop" - "property" - "typedef")) - "\\)" - "\\s-*\\({[^}]+}\\)?" ; optional type - "\\s-*\\[?\\([[:alnum:]_$\.]+\\)?\\]?" ; name - "\\_>") - "Matches jsdoc tags with optional type and optional param name.") - -;; This was taken from js2-mode. -;; and extended with tags in http://usejsdoc.org/ -(defconst typescript-jsdoc-typed-tag-regexp - (concat typescript-jsdoc-before-tag-regexp - "\\(@" - (regexp-opt - '("enum" - "extends" - "field" - "id" - "implements" - "lends" - "mods" - "requires" - "return" - "returns" - "throw" - "throws" - "type" - "yield" - "yields")) - "\\)\\s-*\\({[^}]+}\\)?") - "Matches jsdoc tags with optional type.") - -;; This was taken from js2-mode. -;; and extended with tags in http://usejsdoc.org/ -(defconst typescript-jsdoc-arg-tag-regexp - (concat typescript-jsdoc-before-tag-regexp - "\\(@" - (regexp-opt - '("access" - "alias" - "augments" - "base" - "borrows" - "bug" - "callback" - "config" - "default" - "define" - "emits" - "exception" - "extends" - "external" - "fires" - "func" - "function" - "host" - "kind" - "listens" - "member" - "memberof" - "method" - "mixes" - "module" - "name" - "namespace" - "requires" - "since" - "suppress" - "this" - "throws" - "var" - "variation" - "version")) - "\\)\\s-+\\([^ \t]+\\)") - "Matches jsdoc tags with a single argument.") - -;; This was taken from js2-mode -;; and extended with tags in http://usejsdoc.org/ -(defconst typescript-jsdoc-empty-tag-regexp - (concat typescript-jsdoc-before-tag-regexp - "\\(@" - (regexp-opt - '("abstract" - "addon" - "async" - "author" - "class" - "classdesc" - "const" - "constant" - "constructor" - "constructs" - "copyright" - "default" - "defaultvalue" - "deprecated" - "desc" - "description" - "event" - "example" - "exec" - "export" - "exports" - "file" - "fileoverview" - "final" - "func" - "function" - "generator" - "global" - "hidden" - "hideconstructor" - "ignore" - "implicitcast" - "inheritdoc" - "inner" - "instance" - "interface" - "license" - "method" - "mixin" - "noalias" - "noshadow" - "notypecheck" - "override" - "overview" - "owner" - "package" - "preserve" - "preservetry" - "private" - "protected" - "public" - "readonly" - "static" - "summary" - "supported" - "todo" - "tutorial" - "virtual")) - "\\)\\s-*") - "Matches empty jsdoc tags.") - -;; Note that this regexp by itself would match tslint flags that appear inside -;; strings. The logic using this regexp must guard against it. -(defconst typescript-tslint-flag-regexp - "\\(?://\\|/\\*\\)\\s-*\\(tslint:.*?\\)\\(?:\\*/\\|$\\)" - "Matches tslint flags.") - -;;; Faces - -(defface typescript-jsdoc-tag - '((t :foreground "SlateGray")) - "Face used to highlight @whatever tags in jsdoc comments." - :group 'typescript) - -(defface typescript-jsdoc-type - '((t :foreground "SteelBlue")) - "Face used to highlight {FooBar} types in jsdoc comments." - :group 'typescript) - -(defface typescript-jsdoc-value - '((t :foreground "gold4")) - "Face used to highlight tag values in jsdoc comments." - :group 'typescript) - -(defface typescript-access-modifier-face - '((t (:inherit font-lock-keyword-face))) - "Face used to highlight access modifiers." - :group 'typescript) - -(defface typescript-this-face - '((t (:inherit font-lock-keyword-face))) - "Face used to highlight 'this' keyword." - :group 'typescript) - -(defface typescript-primitive-face - '((t (:inherit font-lock-keyword-face))) - "Face used to highlight builtin types." - :group 'typescript) - -;;; User Customization - -(defgroup typescript nil - "Customization variables for typescript mode." - :tag "typescript" - :group 'languages) - -(defcustom typescript-indent-level 4 - "Number of spaces for each indentation step in `typescript-mode'." - :type 'integer - :safe 'integerp - :group 'typescript) -;;;###autoload(put 'typescript-indent-level 'safe-local-variable #'integerp) - -(defcustom typescript-expr-indent-offset 0 - "Number of additional spaces used for indentation of continued expressions. -The value must be no less than minus `typescript-indent-level'." - :type 'integer - :safe 'integerp - :group 'typescript) - -(defcustom typescript-indent-switch-clauses t - "Enable indenting of switch case and default clauses to -replicate tsserver behaviour. Indent level is taken to be -`typescript-indent-level'." - :type 'boolean - :group 'typescript) - -(defcustom typescript-indent-list-items t - "Enable indenting of list items, useful for certain code styles." - :type 'boolean - :group 'typescript) - -(defcustom typescript-auto-indent-flag t - "Whether to automatically indent when typing punctuation characters. -If non-nil, the characters {}();,: also indent the current line -in typescript mode." - :type 'boolean - :group 'typescript) - -(defcustom typescript-flat-functions nil - "Treat nested functions as top-level functions in `typescript-mode'. -This applies to function movement, marking, and so on." - :type 'boolean - :group 'typescript) - -(defcustom typescript-comment-lineup-func #'c-lineup-C-comments - "Lineup function for `cc-mode-style', for C comments in `typescript-mode'." - :type 'function - :group 'typescript) - -(defcustom typescript-enabled-frameworks typescript--available-frameworks - "Frameworks recognized by `typescript-mode'. -To improve performance, you may turn off some frameworks you -seldom use, either globally or on a per-buffer basis." - :type (cons 'set (mapcar (lambda (x) - (list 'const x)) - typescript--available-frameworks)) - :group 'typescript) - -(defcustom typescript-mode-hook nil - "*Hook called by `typescript-mode'." - :type 'hook - :group 'typescript) - -(defcustom typescript-autoconvert-to-template-flag nil - "Non-nil means automatically convert plain strings to templates. - -When the flag is non-nil the `typescript-autoconvert-to-template' -is called whenever a plain string delimiter is typed in the buffer." - :type 'boolean - :group 'typescript) - -;;; Public utilities - -(defun typescript-convert-to-template () - "Convert the string at point to a template string." - (interactive) - (save-restriction - (widen) - (save-excursion - (let* ((syntax (syntax-ppss)) - (str-terminator (nth 3 syntax)) - (string-start (or (and str-terminator (nth 8 syntax)) - ;; We have to consider the case that we're on the start delimiter of a string. - ;; We tentatively take (point) as string-start. If it turns out we're - ;; wrong, then typescript--move-to-end-of-plain-string will fail anway, - ;; and we won't use the bogus value. - (progn - (forward-char) - (point))))) - (when (typescript--move-to-end-of-plain-string) - (let ((end-start (or (nth 8 (syntax-ppss)) -1))) - (undo-boundary) - (when (= end-start string-start) - (delete-char 1) - (insert "`"))) - (goto-char string-start) - (delete-char 1) - (insert "`")))))) - -(defun typescript-autoconvert-to-template () - "Automatically convert a plain string to a teplate string, if needed. - -This function is meant to be automatically invoked when the user -enters plain string delimiters. It checks whether the character -before point is the end of a string. If it is, then it checks -whether the string contains ${...}. If it does, then it converts -the string from a plain string to a template." - (interactive) - (save-restriction - (widen) - (save-excursion - (backward-char) - (when (and (memq (char-after) '(?' ?\")) - (not (eq (char-before) ?\\))) - (let* ((string-start (nth 8 (syntax-ppss)))) - (when (and string-start - (save-excursion - (re-search-backward "\\${.*?}" string-start t))) - (typescript-convert-to-template))))))) - -;;; KeyMap - -(defvar typescript-mode-map - (let ((keymap (make-sparse-keymap))) - (define-key keymap (kbd "C-c '") #'typescript-convert-to-template) - keymap) - "Keymap for `typescript-mode'.") - -(defun typescript--post-self-insert-function () - (when (and (derived-mode-p 'typescript-mode) - typescript-autoconvert-to-template-flag - (or (eq last-command-event ?\') - (eq last-command-event ?\"))) - (typescript-autoconvert-to-template))) - -;;; Syntax table and parsing - -(defvar typescript-mode-syntax-table - (let ((table (make-syntax-table))) - (c-populate-syntax-table table) - (modify-syntax-entry ?$ "_" table) - (modify-syntax-entry ?` "\"" table) - table) - "Syntax table for `typescript-mode'.") - -(defvar typescript--quick-match-re nil - "Autogenerated regexp used by `typescript-mode' to match buffer constructs.") - -(defvar typescript--quick-match-re-func nil - "Autogenerated regexp used by `typescript-mode' to match constructs and functions.") - -(make-variable-buffer-local 'typescript--quick-match-re) -(make-variable-buffer-local 'typescript--quick-match-re-func) - -(defvar typescript--cache-end 1 - "Last valid buffer position for the `typescript-mode' function cache.") -(make-variable-buffer-local 'typescript--cache-end) - -(defvar typescript--last-parse-pos nil - "Latest parse position reached by `typescript--ensure-cache'.") -(make-variable-buffer-local 'typescript--last-parse-pos) - -(defvar typescript--state-at-last-parse-pos nil - "Parse state at `typescript--last-parse-pos'.") -(make-variable-buffer-local 'typescript--state-at-last-parse-pos) - -(defun typescript--flatten-list (list) - (cl-loop for item in list - nconc (cond ((consp item) - (typescript--flatten-list item)) - (item (list item))))) - -(defun typescript--maybe-join (prefix separator suffix &rest list) - "Helper function for `typescript--update-quick-match-re'. -If LIST contains any element that is not nil, return its non-nil -elements, separated by SEPARATOR, prefixed by PREFIX, and ended -with SUFFIX as with `concat'. Otherwise, if LIST is empty, return -nil. If any element in LIST is itself a list, flatten that -element." - (setq list (typescript--flatten-list list)) - (when list - (concat prefix (mapconcat #'identity list separator) suffix))) - -(defun typescript--update-quick-match-re () - "Internal function used by `typescript-mode' for caching buffer constructs. -This updates `typescript--quick-match-re', based on the current set of -enabled frameworks." - (setq typescript--quick-match-re - (typescript--maybe-join - "^[ \t]*\\(?:" "\\|" "\\)" - - ;; #define mumble - "#define[ \t]+[a-zA-Z_]" - - (when (memq 'exttypescript typescript-enabled-frameworks) - "Ext\\.extend") - - (when (memq 'prototype typescript-enabled-frameworks) - "Object\\.extend") - - ;; var mumble = THING ( - (typescript--maybe-join - "\\(?:var[ \t]+\\)?[a-zA-Z_$0-9.]+[ \t]*=[ \t]*\\(?:" - "\\|" - "\\)[ \t]*\(" - - (when (memq 'prototype typescript-enabled-frameworks) - "Class\\.create") - - (when (memq 'exttypescript typescript-enabled-frameworks) - "Ext\\.extend") - - (when (memq 'merrillpress typescript-enabled-frameworks) - "[a-zA-Z_$0-9]+\\.extend\\(?:Final\\)?")) - - (when (memq 'dojo typescript-enabled-frameworks) - "dojo\\.declare[ \t]*\(") - - (when (memq 'mochikit typescript-enabled-frameworks) - "MochiKit\\.Base\\.update[ \t]*\(") - - ;; mumble.prototypeTHING - (typescript--maybe-join - "[a-zA-Z_$0-9.]+\\.prototype\\(?:" "\\|" "\\)" - - (when (memq 'typescript typescript-enabled-frameworks) - '( ;; foo.prototype.bar = function( - "\\.[a-zA-Z_$0-9]+[ \t]*=[ \t]*function[ \t]*\(" - - ;; mumble.prototype = { - "[ \t]*=[ \t]*{"))))) - - (setq typescript--quick-match-re-func - (concat "function\\|" typescript--quick-match-re))) - -(defun typescript--forward-text-property (propname) - "Move over the next value of PROPNAME in the buffer. -If found, return that value and leave point after the character -having that value; otherwise, return nil and leave point at EOB." - (let ((next-value (get-text-property (point) propname))) - (if next-value - (forward-char) - - (goto-char (next-single-property-change - (point) propname nil (point-max))) - (unless (eobp) - (setq next-value (get-text-property (point) propname)) - (forward-char))) - - next-value)) - -(defun typescript--backward-text-property (propname) - "Move over the previous value of PROPNAME in the buffer. -If found, return that value and leave point just before the -character that has that value, otherwise return nil and leave -point at BOB." - (unless (bobp) - (let ((prev-value (get-text-property (1- (point)) propname))) - (if prev-value - (backward-char) - - (goto-char (previous-single-property-change - (point) propname nil (point-min))) - - (unless (bobp) - (backward-char) - (setq prev-value (get-text-property (point) propname)))) - - prev-value))) - -(defsubst typescript--forward-pstate () - (typescript--forward-text-property 'typescript--pstate)) - -(defsubst typescript--backward-pstate () - (typescript--backward-text-property 'typescript--pstate)) - -(defun typescript--pitem-goto-h-end (pitem) - (goto-char (typescript--pitem-h-begin pitem)) - (typescript--forward-pstate)) - -(defun typescript--re-search-forward-inner (regexp &optional bound count) - "Helper function for `typescript--re-search-forward'." - (let ((parse) - str-terminator) - (while (> count 0) - (re-search-forward regexp bound) - (setq parse (syntax-ppss)) - (cond ((setq str-terminator (nth 3 parse)) - (when (eq str-terminator t) - (setq str-terminator ?/)) - (re-search-forward - (concat "\\([^\\]\\|^\\)" (string str-terminator)) - (save-excursion (end-of-line) (point)) t)) - ((nth 7 parse) - (forward-line)) - ((or (nth 4 parse) - (and (eq (char-before) ?\/) (eq (char-after) ?\*))) - (re-search-forward "\\*/")) - (t - (setq count (1- count)))))) - (point)) - - -(defun typescript--re-search-forward (regexp &optional bound noerror count) - "Search forward, ignoring strings and comments. -This function invokes `re-search-forward', but treats the buffer -as if strings and comments have been removed." - (let ((saved-point (point)) - (search-expr - (cond ((null count) - '(typescript--re-search-forward-inner regexp bound 1)) - ((< count 0) - '(typescript--re-search-backward-inner regexp bound (- count))) - ((> count 0) - '(typescript--re-search-forward-inner regexp bound count))))) - (condition-case err - (eval search-expr) - (search-failed - (goto-char saved-point) - (unless noerror - (error (error-message-string err))))))) - - -(defun typescript--re-search-backward-inner (regexp &optional bound count) - "Auxiliary function for `typescript--re-search-backward'." - (let ((parse)) - (while (> count 0) - (re-search-backward regexp bound) - (when (and (> (point) (point-min)) - (save-excursion (backward-char) (looking-at "/[/*]"))) - (forward-char)) - (setq parse (syntax-ppss)) - (cond - ;; If we are in a comment or a string, jump back to the start - ;; of the comment or string. - ((nth 8 parse) - (goto-char (nth 8 parse))) - ((and (eq (char-before) ?/) (eq (char-after) ?*)) - (re-search-backward "/\\*")) - (t - (setq count (1- count)))))) - (point)) - - -(defun typescript--re-search-backward (regexp &optional bound noerror count) - "Search backward, ignoring strings, and comments. - -This function invokes `re-search-backward' but treats the buffer -as if strings and comments have been removed. - -IMPORTANT NOTE: searching for \"\\n\" with this function to find -line breaks will generally not work, because the final newline of -a one-line comment is considered to be part of the comment and -will be skipped. Take the following code: - - let a = 1; - let b = 2; // Foo - let c = 3; - -If the point is in the last line, searching back for \"\\n\" will -skip over the line with \"let b\". The newline found will be the -one at the end of the line with \"let a\"." - (let ((saved-point (point)) - (search-expr - (cond ((null count) - `(typescript--re-search-backward-inner ,regexp ,bound 1)) - ((< count 0) - `(typescript--re-search-forward-inner ,regexp ,bound (- ,count))) - ((> count 0) - `(typescript--re-search-backward-inner ,regexp ,bound ,count))))) - (condition-case err - (eval search-expr) - (search-failed - (goto-char saved-point) - (unless noerror - (error (error-message-string err))))))) - -(defun typescript--forward-expression () - "Move forward over a whole typescript expression. -This function doesn't move over expressions continued across -lines." - (cl-loop - do (progn - (forward-comment most-positive-fixnum) - (cl-loop until (or (eolp) - (progn - (forward-comment most-positive-fixnum) - (memq (char-after) '(?\, ?\; ?\] ?\) ?\})))) - do (forward-sexp))) - while (and (eq (char-after) ?\n) - (save-excursion - (forward-char) - (typescript--continued-expression-p))))) - -(defun typescript--forward-function-decl () - "Move forward over a typescript function declaration. -This puts point at the 'function' keyword. - -If this is a syntactically-correct non-expression function, -return the name of the function, or t if the name could not be -determined. Otherwise, return nil." - (cl-assert (looking-at "\\_<function\\_>")) - (let ((name t)) - (forward-word) - (forward-comment most-positive-fixnum) - (when (looking-at typescript--name-re) - (setq name (match-string-no-properties 0)) - (goto-char (match-end 0))) - (forward-comment most-positive-fixnum) - (and (eq (char-after) ?\( ) - (ignore-errors (forward-list) t) - (progn (forward-comment most-positive-fixnum) - (and (eq (char-after) ?{) - name))))) - -(defun typescript--function-prologue-beginning (&optional pos) - "Return the start of the typescript function prologue containing POS. -A function prologue is everything from start of the definition up -to and including the opening brace. POS defaults to point. -If POS is not in a function prologue, return nil." - (let (prologue-begin) - (save-excursion - (if pos - (goto-char pos) - (setq pos (point))) - - (when (save-excursion - (forward-line 0) - (or (looking-at typescript--function-heading-2-re) - (looking-at typescript--function-heading-3-re))) - - (setq prologue-begin (match-beginning 1)) - (when (<= prologue-begin pos) - (goto-char (match-end 0)))) - - (skip-syntax-backward "w_") - (and (or (looking-at "\\_<function\\_>") - (typescript--re-search-backward "\\_<function\\_>" nil t)) - - (save-match-data (goto-char (match-beginning 0)) - (typescript--forward-function-decl)) - - (<= pos (point)) - (or prologue-begin (match-beginning 0)))))) - -(defun typescript--beginning-of-defun-raw () - "Helper function for `typescript-beginning-of-defun'. -Go to previous defun-beginning and return the parse state for it, -or nil if we went all the way back to bob and don't find -anything." - (typescript--ensure-cache) - (let (pstate) - (while (and (setq pstate (typescript--backward-pstate)) - (not (eq 'function (typescript--pitem-type (car pstate)))))) - (and (not (bobp)) pstate))) - -(defun typescript--pstate-is-toplevel-defun (pstate) - "Helper function for `typescript--beginning-of-defun-nested'. -If PSTATE represents a non-empty top-level defun, return the -top-most pitem. Otherwise, return nil." - (cl-loop for pitem in pstate - with func-depth = 0 - with func-pitem - if (eq 'function (typescript--pitem-type pitem)) - do (cl-incf func-depth) - and do (setq func-pitem pitem) - finally return (if (eq func-depth 1) func-pitem))) - -(defun typescript--beginning-of-defun-nested () - "Helper function for `typescript--beginning-of-defun'. -Return the pitem of the function we went to the beginning of." - (or - ;; Look for the smallest function that encloses point... - (cl-loop for pitem in (typescript--parse-state-at-point) - if (and (eq 'function (typescript--pitem-type pitem)) - (typescript--inside-pitem-p pitem)) - do (goto-char (typescript--pitem-h-begin pitem)) - and return pitem) - - ;; ...and if that isn't found, look for the previous top-level - ;; defun - (cl-loop for pstate = (typescript--backward-pstate) - while pstate - if (typescript--pstate-is-toplevel-defun pstate) - do (goto-char (typescript--pitem-h-begin it)) - and return it))) - -(defun typescript--beginning-of-defun-flat () - "Helper function for `typescript-beginning-of-defun'." - (let ((pstate (typescript--beginning-of-defun-raw))) - (when pstate - (goto-char (typescript--pitem-h-begin (car pstate)))))) - -(defun typescript-beginning-of-defun (&optional arg) - "Value of `beginning-of-defun-function' for `typescript-mode'." - (setq arg (or arg 1)) - (while (and (not (eobp)) (< arg 0)) - (cl-incf arg) - (when (and (not typescript-flat-functions) - (or (eq (typescript-syntactic-context) 'function) - (typescript--function-prologue-beginning))) - (typescript-end-of-defun)) - - (if (typescript--re-search-forward - "\\_<function\\_>" nil t) - (goto-char (typescript--function-prologue-beginning)) - (goto-char (point-max)))) - - (while (> arg 0) - (cl-decf arg) - ;; If we're just past the end of a function, the user probably wants - ;; to go to the beginning of *that* function - (when (eq (char-before) ?}) - (backward-char)) - - (let ((prologue-begin (typescript--function-prologue-beginning))) - (cond ((and prologue-begin (< prologue-begin (point))) - (goto-char prologue-begin)) - - (typescript-flat-functions - (typescript--beginning-of-defun-flat)) - (t - (typescript--beginning-of-defun-nested)))))) - -(defun typescript--flush-caches (&optional beg ignored) - "Flush the `typescript-mode' syntax cache after position BEG. -BEG defaults to `point-min', meaning to flush the entire cache." - (interactive) - (setq beg (or beg (save-restriction (widen) (point-min)))) - (setq typescript--cache-end (min typescript--cache-end beg))) - -(defmacro typescript--debug (&rest arguments) - ;; `(message ,@arguments) - ) - -(defun typescript--ensure-cache--pop-if-ended (open-items paren-depth) - (let ((top-item (car open-items))) - (when (<= paren-depth (typescript--pitem-paren-depth top-item)) - (cl-assert (not (get-text-property (1- (point)) 'typescript-pend))) - (put-text-property (1- (point)) (point) 'typescript--pend top-item) - (setf (typescript--pitem-b-end top-item) (point)) - (setq open-items - ;; open-items must contain at least two items for this to - ;; work, but because we push a dummy item to start with, - ;; that assumption holds. - (cons (typescript--pitem-add-child (cl-second open-items) top-item) - (cddr open-items))))) - open-items) - -(defmacro typescript--ensure-cache--update-parse () - "Helper function for `typescript--ensure-cache'. -Update parsing information up to point, referring to parse, -prev-parse-point, goal-point, and open-items bound lexically in -the body of `typescript--ensure-cache'." - `(progn - (setq goal-point (point)) - (goto-char prev-parse-point) - (while (progn - (setq open-items (typescript--ensure-cache--pop-if-ended - open-items (car parse))) - ;; Make sure parse-partial-sexp doesn't stop because we *entered* - ;; the given depth -- i.e., make sure we're deeper than the target - ;; depth. - (cl-assert (> (nth 0 parse) - (typescript--pitem-paren-depth (car open-items)))) - (setq parse (parse-partial-sexp - prev-parse-point goal-point - (typescript--pitem-paren-depth (car open-items)) - nil parse)) - -;; (let ((overlay (make-overlay prev-parse-point (point)))) -;; (overlay-put overlay 'face '(:background "red")) -;; (unwind-protect -;; (progn -;; (typescript--debug "parsed: %S" parse) -;; (sit-for 1)) -;; (delete-overlay overlay))) - - (setq prev-parse-point (point)) - (< (point) goal-point))) - - (setq open-items (typescript--ensure-cache--pop-if-ended - open-items (car parse))))) - -(defun typescript--show-cache-at-point () - (interactive) - (require 'pp) - (let ((prop (get-text-property (point) 'typescript--pstate))) - (with-output-to-temp-buffer "*Help*" - (pp prop)))) - -(defun typescript--split-name (string) - "Split a typescript name into its dot-separated parts. -This also removes any prototype parts from the split name -\(unless the name is just \"prototype\" to start with)." - (let ((name (save-match-data - (split-string string "\\." t)))) - (unless (and (= (length name) 1) - (equal (car name) "prototype")) - - (setq name (remove "prototype" name))))) - -(defvar typescript--guess-function-name-start nil) - -(defun typescript--guess-function-name (position) - "Guess the name of the typescript function at POSITION. -POSITION should be just after the end of the word \"function\". -Return the name of the function, or nil if the name could not be -guessed. - -This function clobbers match data. If we find the preamble -begins earlier than expected while guessing the function name, -set `typescript--guess-function-name-start' to that position; otherwise, -set that variable to nil." - (setq typescript--guess-function-name-start nil) - (save-excursion - (goto-char position) - (forward-line 0) - (cond - ((looking-at typescript--function-heading-3-re) - (and (eq (match-end 0) position) - (setq typescript--guess-function-name-start (match-beginning 1)) - (match-string-no-properties 1))) - - ((looking-at typescript--function-heading-2-re) - (and (eq (match-end 0) position) - (setq typescript--guess-function-name-start (match-beginning 1)) - (match-string-no-properties 1)))))) - -(defun typescript--clear-stale-cache () - ;; Clear any endings that occur after point - (let (end-prop) - (save-excursion - (while (setq end-prop (typescript--forward-text-property - 'typescript--pend)) - (setf (typescript--pitem-b-end end-prop) nil)))) - - ;; Remove any cache properties after this point - (remove-text-properties (point) (point-max) - '(typescript--pstate t typescript--pend t))) - -(defun typescript--ensure-cache (&optional limit) - "Ensures brace cache is valid up to the character before LIMIT. -LIMIT defaults to point." - (setq limit (or limit (point))) - (when (< typescript--cache-end limit) - - (c-save-buffer-state - (open-items - orig-match-start - orig-match-end - orig-depth - parse - prev-parse-point - name - case-fold-search - filtered-class-styles - new-item - goal-point - end-prop) - - ;; Figure out which class styles we need to look for - (setq filtered-class-styles - (cl-loop for style in typescript--class-styles - if (memq (plist-get style :framework) - typescript-enabled-frameworks) - collect style)) - - (save-excursion - (save-restriction - (widen) - - ;; Find last known good position - (goto-char typescript--cache-end) - (unless (bobp) - (setq open-items (get-text-property - (1- (point)) 'typescript--pstate)) - - (unless open-items - (goto-char (previous-single-property-change - (point) 'typescript--pstate nil (point-min))) - - (unless (bobp) - (setq open-items (get-text-property (1- (point)) - 'typescript--pstate)) - (cl-assert open-items)))) - - (unless open-items - ;; Make a placeholder for the top-level definition - (setq open-items (list typescript--initial-pitem))) - - (setq parse (syntax-ppss)) - (setq prev-parse-point (point)) - - (typescript--clear-stale-cache) - - (narrow-to-region (point-min) limit) - - (cl-loop while (re-search-forward typescript--quick-match-re-func nil t) - for orig-match-start = (goto-char (match-beginning 0)) - for orig-match-end = (match-end 0) - do (typescript--ensure-cache--update-parse) - for orig-depth = (nth 0 parse) - - ;; Each of these conditions should return non-nil if - ;; we should add a new item and leave point at the end - ;; of the new item's header (h-end in the - ;; typescript--pitem diagram). This point is the one - ;; after the last character we need to unambiguously - ;; detect this construct. If one of these evaluates to - ;; nil, the location of the point is ignored. - if (cond - ;; In comment or string - ((nth 8 parse) nil) - - ;; Regular function declaration - ((and (looking-at "\\_<function\\_>") - (setq name (typescript--forward-function-decl))) - - (when (eq name t) - (setq name (typescript--guess-function-name orig-match-end)) - (if name - (when typescript--guess-function-name-start - (setq orig-match-start - typescript--guess-function-name-start)) - - (setq name t))) - - (cl-assert (eq (char-after) ?{)) - (forward-char) - (make-typescript--pitem - :paren-depth orig-depth - :h-begin orig-match-start - :type 'function - :name (if (eq name t) - name - (typescript--split-name name)))) - - ;; "Prototype function" declaration - ((looking-at typescript--plain-method-re) - (goto-char (match-beginning 3)) - (when (save-match-data - (typescript--forward-function-decl)) - (forward-char) - (make-typescript--pitem - :paren-depth orig-depth - :h-begin orig-match-start - :type 'function - :name (nconc (typescript--split-name - (match-string-no-properties 1)) - (list (match-string-no-properties 2)))))) - - ;; Class definition - ((cl-loop with syntactic-context = - (typescript--syntactic-context-from-pstate open-items) - for class-style in filtered-class-styles - if (and (memq syntactic-context - (plist-get class-style :contexts)) - (looking-at (plist-get class-style - :class-decl))) - do (goto-char (match-end 0)) - and return - (make-typescript--pitem - :paren-depth orig-depth - :h-begin orig-match-start - :type class-style - :name (typescript--split-name - (match-string-no-properties 1)))))) - - do (typescript--ensure-cache--update-parse) - and do (push it open-items) - and do (put-text-property - (1- (point)) (point) 'typescript--pstate open-items) - else do (goto-char orig-match-end)) - - (goto-char limit) - (typescript--ensure-cache--update-parse) - (setq typescript--cache-end limit) - (setq typescript--last-parse-pos limit) - (setq typescript--state-at-last-parse-pos open-items)))))) - -(defun typescript--end-of-defun-flat () - "Helper function for `typescript-end-of-defun'." - (cl-loop while (typescript--re-search-forward "}" nil t) - do (typescript--ensure-cache) - if (get-text-property (1- (point)) 'typescript--pend) - if (eq 'function (typescript--pitem-type it)) - return t - finally do (goto-char (point-max)))) - -(defun typescript--end-of-defun-nested () - "Helper function for `typescript-end-of-defun'." - (let* (pitem - (this-end (save-excursion - (and (setq pitem (typescript--beginning-of-defun-nested)) - (typescript--pitem-goto-h-end pitem) - (progn (backward-char) - (forward-list) - (point))))) - found) - - (if (and this-end (< (point) this-end)) - ;; We're already inside a function; just go to its end. - (goto-char this-end) - - ;; Otherwise, go to the end of the next function... - (while (and (typescript--re-search-forward "\\_<function\\_>" nil t) - (not (setq found (progn - (goto-char (match-beginning 0)) - (typescript--forward-function-decl)))))) - - (if found (forward-list) - ;; ... or eob. - (goto-char (point-max)))))) - -(defun typescript-end-of-defun (&optional arg) - "Value of `end-of-defun-function' for `typescript-mode'." - (setq arg (or arg 1)) - (while (and (not (bobp)) (< arg 0)) - (cl-incf arg) - (typescript-beginning-of-defun) - (typescript-beginning-of-defun) - (unless (bobp) - (typescript-end-of-defun))) - - (while (> arg 0) - (cl-decf arg) - ;; look for function backward. if we're inside it, go to that - ;; function's end. otherwise, search for the next function's end and - ;; go there - (if typescript-flat-functions - (typescript--end-of-defun-flat) - - ;; if we're doing nested functions, see whether we're in the - ;; prologue. If we are, go to the end of the function; otherwise, - ;; call typescript--end-of-defun-nested to do the real work - (let ((prologue-begin (typescript--function-prologue-beginning))) - (cond ((and prologue-begin (<= prologue-begin (point))) - (goto-char prologue-begin) - (re-search-forward "\\_<function") - (goto-char (match-beginning 0)) - (typescript--forward-function-decl) - (forward-list)) - - (t (typescript--end-of-defun-nested))))))) - -(defun typescript--backward-syntactic-ws (&optional lim) - "Simple implementation of `c-backward-syntactic-ws' for `typescript-mode'." - (save-restriction - (when lim (narrow-to-region lim (point-max))) - - (let ((pos (point))) - (while (progn (forward-comment most-negative-fixnum) - (/= (point) - (prog1 - pos - (setq pos (point))))))))) - -(defun typescript--forward-syntactic-ws (&optional lim) - "Simple implementation of `c-forward-syntactic-ws' for `typescript-mode'." - (save-restriction - (when lim (narrow-to-region (point-min) lim)) - (let ((pos (point))) - (while (progn - (forward-comment most-positive-fixnum) - (/= (point) - (prog1 - pos - (setq pos (point))))))))) - -;; Like (up-list -1), but only considers lists that end nearby" -(defun typescript--up-nearby-list () - (save-restriction - ;; Look at a very small region so our compuation time doesn't - ;; explode in pathological cases. - (narrow-to-region (max (point-min) (- (point) 500)) (point)) - (up-list -1))) - -(defun typescript--inside-param-list-p () - "Return non-nil iff point is in a function parameter list." - (ignore-errors - (save-excursion - (typescript--up-nearby-list) - (and (looking-at "(") - (progn (forward-symbol -1) - (or (looking-at "function") - (progn (forward-symbol -1) - (looking-at "function")))))))) - -(defun typescript--inside-dojo-class-list-p () - "Return non-nil iff point is in a Dojo multiple-inheritance class block." - (ignore-errors - (save-excursion - (typescript--up-nearby-list) - (let ((list-begin (point))) - (forward-line 0) - (and (looking-at typescript--dojo-class-decl-re) - (goto-char (match-end 0)) - (looking-at "\"\\s-*,\\s-*\\[") - (eq (match-end 0) (1+ list-begin))))))) - -(defun typescript--syntax-begin-function () - (when (< typescript--cache-end (point)) - (goto-char (max (point-min) typescript--cache-end))) - - (let ((pitem)) - (while (and (setq pitem (car (typescript--backward-pstate))) - (not (eq 0 (typescript--pitem-paren-depth pitem))))) - - (when pitem - (goto-char (typescript--pitem-h-begin pitem ))))) - -(defun typescript--move-to-end-of-plain-string () - "If the point is in a plain string, move to the end of it. - -Otherwise, don't move. A plain string is a string which is not a -template string. The point is considered to be \"in\" a string if -it is on the delimiters of the string, or any point inside. - -Returns point if the end of the string was found, or nil if the -end of the string was not found." - (let ((end-position - (save-excursion - (let* ((syntax (syntax-ppss)) - (str-terminator (nth 3 syntax)) - ;; The 8th element will also be set if we are in a comment. So we - ;; check str-terminator to protect against that. - (string-start (and str-terminator - (nth 8 syntax)))) - (if (and string-start - (not (eq str-terminator ?`))) - ;; We may already be at the end of the string. - (if (and (eq (char-after) str-terminator) - (not (eq (char-before) ?\\))) - (point) - ;; We just search forward and then check if the hit we get has a - ;; string-start equal to ours. - (cl-loop while (re-search-forward - (concat "\\(?:[^\\]\\|^\\)\\(" (string str-terminator) "\\)") - nil t) - if (eq string-start - (save-excursion (nth 8 (syntax-ppss (match-beginning 1))))) - return (match-beginning 1))) - ;; If we are on the start delimiter then the value of syntax-ppss will look - ;; like we're not in a string at all, but this function considers the - ;; start delimiter to be "in" the string. We take care of this here. - (when (memq (char-after) '(?' ?\")) - (forward-char) - (typescript--move-to-end-of-plain-string))))))) - (when end-position - (goto-char end-position)))) - -;;; Font Lock -(defun typescript--make-framework-matcher (framework &rest regexps) - "Helper function for building `typescript--font-lock-keywords'. -Create a byte-compiled function for matching a concatenation of -REGEXPS, but only if FRAMEWORK is in `typescript-enabled-frameworks'." - (setq regexps (apply #'concat regexps)) - (byte-compile - `(lambda (limit) - (when (memq (quote ,framework) typescript-enabled-frameworks) - (re-search-forward ,regexps limit t))))) - -(defvar typescript--tmp-location nil) -(make-variable-buffer-local 'typescript--tmp-location) - -(defun typescript--forward-destructuring-spec (&optional func) - "Move forward over a typescript destructuring spec. -If FUNC is supplied, call it with no arguments before every -variable name in the spec. Return true iff this was actually a -spec. FUNC must preserve the match data." - (cl-case (char-after) - (?\[ - (forward-char) - (while - (progn - (forward-comment most-positive-fixnum) - (cond ((memq (char-after) '(?\[ ?\{)) - (typescript--forward-destructuring-spec func)) - - ((eq (char-after) ?,) - (forward-char) - t) - - ((looking-at typescript--name-re) - (and func (funcall func)) - (goto-char (match-end 0)) - t)))) - (when (eq (char-after) ?\]) - (forward-char) - t)) - - (?\{ - (forward-char) - (forward-comment most-positive-fixnum) - (while - (when (looking-at typescript--objfield-re) - (goto-char (match-end 0)) - (forward-comment most-positive-fixnum) - (and (cond ((memq (char-after) '(?\[ ?\{)) - (typescript--forward-destructuring-spec func)) - ((looking-at typescript--name-re) - (and func (funcall func)) - (goto-char (match-end 0)) - t)) - (progn (forward-comment most-positive-fixnum) - (when (eq (char-after) ?\,) - (forward-char) - (forward-comment most-positive-fixnum) - t))))) - (when (eq (char-after) ?\}) - (forward-char) - t)))) - -(defun typescript--variable-decl-matcher (limit) - "Font-lock matcher for variable names in a variable declaration. -This is a cc-mode-style matcher that *always* fails, from the -point of view of font-lock. It applies highlighting directly with -`font-lock-apply-highlight'." - (condition-case nil - (save-restriction - (narrow-to-region (point-min) limit) - - (let ((first t)) - (forward-comment most-positive-fixnum) - (while - (and (or first - (when (eq (char-after) ?,) - (forward-char) - (forward-comment most-positive-fixnum) - t)) - (cond ((looking-at typescript--name-re) - (font-lock-apply-highlight - '(0 font-lock-variable-name-face)) - (goto-char (match-end 0))) - - ((save-excursion - (typescript--forward-destructuring-spec)) - - (typescript--forward-destructuring-spec - (lambda () - (font-lock-apply-highlight - '(0 font-lock-variable-name-face))))))) - - (forward-comment most-positive-fixnum) - (when (eq (char-after) ?=) - (forward-char) - (typescript--forward-expression) - (forward-comment most-positive-fixnum)) - - (setq first nil)))) - - ;; Conditions to handle - (scan-error nil) - (end-of-buffer nil)) - - ;; Matcher always "fails" - nil) - -(defun typescript--in-documentation-comment-p () - "Reports whether point is inside a documentation comment." - (let ((parse (syntax-ppss))) - (and - (nth 4 parse) ;; Inside a comment ... - (save-match-data - (save-excursion - (goto-char (nth 8 parse)) - (looking-at "/\\*\\*")))))) ;; ... which starts with /** - -(defun typescript--documentation-font-lock-helper (re limit) - "This is a helper macro that determines whether jsdoc highlighting is to be applied, -and searches for the next token to be highlighted." - (cl-loop while (re-search-forward re limit t) - if (typescript--in-documentation-comment-p) - return (point))) - -(defun typescript--jsdoc-param-matcher (limit) - "Font-lock mode matcher that finds jsdoc parameter tags in documentation." - (typescript--documentation-font-lock-helper typescript-jsdoc-param-tag-regexp limit)) - -(defun typescript--jsdoc-typed-tag-matcher (limit) - "Font-lock mode matcher that finds jsdoc typed tags in documentation." - (typescript--documentation-font-lock-helper typescript-jsdoc-typed-tag-regexp limit)) - -(defun typescript--jsdoc-arg-tag-matcher (limit) - "Font-lock mode matcher that finds jsdoc tags that take one argument in documentation." - (typescript--documentation-font-lock-helper typescript-jsdoc-arg-tag-regexp limit)) - -(defun typescript--jsdoc-empty-tag-matcher (limit) - "Font-lock mode matcher that finds jsdoc tags without argument in documentation." - (typescript--documentation-font-lock-helper typescript-jsdoc-empty-tag-regexp limit)) - -(defun typescript--typedoc-link-matcher (limit) - "Font-lock mode matcher that finds typedoc links in documentation." - (typescript--documentation-font-lock-helper typescript-typedoc-link-tag-regexp limit)) - -(defun typescript--typedoc-literal-markup-matcher (limit) - "Font-lock mode matcher that finds typedoc literal markup in documentation." - (typescript--documentation-font-lock-helper typescript-typedoc-literal-markup-regexp limit)) - -(defun typescript--tslint-flag-matcher (limit) - "Font-lock mode matcher that finds tslint flags in comments." - (cl-loop while (re-search-forward typescript-tslint-flag-regexp limit t) - if (nth 4 (syntax-ppss (match-beginning 1))) - return (point))) - -(defconst typescript--font-lock-keywords-3 - `( - ,@typescript--font-lock-keywords-2 - - (typescript--jsdoc-param-matcher (1 'typescript-jsdoc-tag t t) - (2 'typescript-jsdoc-type t t) - (3 'typescript-jsdoc-value t t)) - - (typescript--jsdoc-typed-tag-matcher (1 'typescript-jsdoc-tag t t) - (2 'typescript-jsdoc-type t t)) - - (typescript--jsdoc-arg-tag-matcher (1 'typescript-jsdoc-tag t t) - (2 'typescript-jsdoc-value t t)) - - (typescript--jsdoc-empty-tag-matcher (1 'typescript-jsdoc-tag t t)) - - (typescript--typedoc-link-matcher (0 'typescript-jsdoc-value t)) - - (typescript--typedoc-literal-markup-matcher - (0 'typescript-jsdoc-value t)) - - (typescript--tslint-flag-matcher - (1 font-lock-preprocessor-face t)) - - ("\\.\\(prototype\\)\\_>" - (1 font-lock-constant-face)) - - (,(rx symbol-start "class" (+ space) (group (+ (or (syntax word) (syntax symbol))))) - (1 font-lock-type-face)) - - (,(rx symbol-start "extends" (+ space) (group (+ (or (syntax word) (syntax symbol))))) - (1 font-lock-type-face)) - - (,(rx symbol-start "implements" (+ space)) - (,(rx symbol-start (+ (syntax word))) nil nil (0 font-lock-type-face))) - - (,(rx symbol-start "interface" (+ space) (group (+ (or (syntax word) (syntax symbol))))) - (1 font-lock-type-face)) - - (,(rx symbol-start "type" (+ space) (group (+ (or (syntax word) (syntax symbol))))) - (1 font-lock-type-face)) - - (,(rx symbol-start "enum" (+ space) (group (+ (or (syntax word) (syntax symbol))))) - (1 font-lock-type-face)) - - ;; Highlights class being declared, in parts - (typescript--class-decl-matcher - ,(concat "\\(" typescript--name-re "\\)\\(?:\\.\\|.*$\\)") - (goto-char (match-beginning 1)) - nil - (1 font-lock-type-face)) - - ;; Highlights parent class, in parts, if available - (typescript--class-decl-matcher - ,(concat "\\(" typescript--name-re "\\)\\(?:\\.\\|.*$\\)") - (if (match-beginning 2) - (progn - (setq typescript--tmp-location (match-end 2)) - (goto-char typescript--tmp-location) - (insert "=") - (goto-char (match-beginning 2))) - (setq typescript--tmp-location nil) - (goto-char (point-at-eol))) - (when typescript--tmp-location - (save-excursion - (goto-char typescript--tmp-location) - (delete-char 1))) - (1 font-lock-type-face)) - - ;; Highlights parent class - (typescript--class-decl-matcher - (2 font-lock-type-face nil t)) - - ;; Dojo needs its own matcher to override the string highlighting - (,(typescript--make-framework-matcher - 'dojo - "^\\s-*dojo\\.declare\\s-*(\"" - "\\(" typescript--dotted-name-re "\\)" - "\\(?:\"\\s-*,\\s-*\\(" typescript--dotted-name-re "\\)\\)?") - (1 font-lock-type-face t) - (2 font-lock-type-face nil t)) - - ;; Match Dojo base classes. Of course Mojo has to be different - ;; from everything else under the sun... - (,(typescript--make-framework-matcher - 'dojo - "^\\s-*dojo\\.declare\\s-*(\"" - "\\(" typescript--dotted-name-re "\\)\"\\s-*,\\s-*\\[") - ,(concat "[[,]\\s-*\\(" typescript--dotted-name-re "\\)\\s-*" - "\\(?:\\].*$\\)?") - (backward-char) - (end-of-line) - (1 font-lock-type-face)) - - ;; continued Dojo base-class list - (,(typescript--make-framework-matcher - 'dojo - "^\\s-*" typescript--dotted-name-re "\\s-*[],]") - ,(concat "\\(" typescript--dotted-name-re "\\)" - "\\s-*\\(?:\\].*$\\)?") - (if (save-excursion (backward-char) - (typescript--inside-dojo-class-list-p)) - (forward-symbol -1) - (end-of-line)) - (end-of-line) - (1 font-lock-type-face)) - - ;; variable declarations - ,(list - (concat "\\_<\\(const\\|var\\|let\\)\\_>\\|" typescript--basic-type-re) - (list #'typescript--variable-decl-matcher nil nil nil)) - - ;; class instantiation - ,(list - (concat "\\_<new\\_>\\s-+\\(" typescript--dotted-name-re "\\)") - (list 1 'font-lock-type-face)) - - ;; instanceof - ,(list - (concat "\\_<instanceof\\_>\\s-+\\(" typescript--dotted-name-re "\\)") - (list 1 'font-lock-type-face)) - - ;; formal parameters - ,(list - (concat - "\\_<function\\_>\\(\\s-+" typescript--name-re "\\)?\\s-*\\(<.*>\\)?\\s-*(\\s-*" - typescript--name-start-re) - (list (concat "\\(" typescript--name-re "\\)\\(\\s-*).*\\)?") - '(backward-char) - '(end-of-line) - '(1 font-lock-variable-name-face))) - - ;; continued formal parameter list - ,(list - (concat - "^\\s-*" typescript--name-re "\\s-*[,)]") - (list typescript--name-re - '(if (save-excursion (backward-char) - (typescript--inside-param-list-p)) - (forward-symbol -1) - (end-of-line)) - '(end-of-line) - '(0 font-lock-variable-name-face)))) - "Level three font lock for `typescript-mode'.") - -(defun typescript--flyspell-mode-predicate () - "A custom predicate to help `flyspell-prog-mode' determine whether a word should be checked." - ;; We depend on fontification for our results. font-lock-ensure is defined on - ;; Emacs 25 and over. Earlier versions use font-lock-fontify-buffer. - (if (fboundp 'font-lock-ensure) - (font-lock-ensure) - (font-lock-fontify-buffer)) - (and - ;; Check with the default method that flyspell provides. - (flyspell-generic-progmode-verify) - - ;; - ;; And eliminate cases specific to our mode we don't want to have - ;; spell-checked. - ;; - - ;; Don't check the module names in import statements. - (save-excursion - (not (let* ((parse (syntax-ppss (1- (point)))) - (string-start-pos (and (nth 3 parse) - (nth 8 parse)))) - (and string-start-pos - (save-match-data - ;; Move to back to the start of the string, then past any ws - ;; and then past any non-ws to see if we have "from" or "import". - (goto-char string-start-pos) - (typescript--backward-syntactic-ws) - (skip-syntax-backward "^-" (point-at-bol)) - (looking-at "from\\|import\\s-")))))))) - -(defun typescript--inside-pitem-p (pitem) - "Return whether point is inside the given pitem's header or body." - (typescript--ensure-cache) - (cl-assert (typescript--pitem-h-begin pitem)) - (cl-assert (typescript--pitem-paren-depth pitem)) - - (and (> (point) (typescript--pitem-h-begin pitem)) - (or (null (typescript--pitem-b-end pitem)) - (> (typescript--pitem-b-end pitem) (point))))) - -(defun typescript--parse-state-at-point () - "Parse the typescript program state at point. -Return a list of `typescript--pitem' instances that apply to point, most -specific first. In the worst case, the current toplevel instance -will be returned." - (save-excursion - (save-restriction - (widen) - (typescript--ensure-cache) - (let* ((bound (if (eobp) (point) (1+ (point)))) - (pstate (or (save-excursion - (typescript--backward-pstate)) - (list typescript--initial-pitem)))) - - ;; Loop until we either hit a pitem at BOB or pitem ends after - ;; point (or at point if we're at eob) - (cl-loop for pitem = (car pstate) - until (or (eq (typescript--pitem-type pitem) - 'toplevel) - (typescript--inside-pitem-p pitem)) - do (pop pstate)) - - pstate)))) - -(defun typescript--syntactic-context-from-pstate (pstate) - "Return the typescript syntactic context corresponding to PSTATE." - (let ((type (typescript--pitem-type (car pstate)))) - (cond ((memq type '(function macro)) - type) - ((consp type) - 'class) - (t 'toplevel)))) - -(defun typescript-syntactic-context () - "Return the typescript syntactic context at point. -When called interatively, also display a message with that -context." - (interactive) - (let* ((syntactic-context (typescript--syntactic-context-from-pstate - (typescript--parse-state-at-point)))) - - (when (called-interactively-p 'interactive) - (message "Syntactic context: %s" syntactic-context)) - - syntactic-context)) - -(defun typescript--class-decl-matcher (limit) - "Font lock function used by `typescript-mode'. -This performs fontification according to `typescript--class-styles'." - (cl-loop initially (typescript--ensure-cache limit) - while (re-search-forward typescript--quick-match-re limit t) - for orig-end = (match-end 0) - do (goto-char (match-beginning 0)) - if (cl-loop for style in typescript--class-styles - for decl-re = (plist-get style :class-decl) - if (and (memq (plist-get style :framework) - typescript-enabled-frameworks) - (memq (typescript-syntactic-context) - (plist-get style :contexts)) - decl-re - (looking-at decl-re)) - do (goto-char (match-end 0)) - and return t) - return t - else do (goto-char orig-end))) - -(defconst typescript--font-lock-keywords-4 - `( - ;; highlights that override previous levels - ;; - - ;; special highlight for `this' keyword - ("\\(this\\)\\." - (1 'typescript-this-face)) - - (,typescript--access-modifier-re (1 'typescript-access-modifier-face)) - (,typescript--basic-type-re (1 'typescript-primitive-face)) - - ;; generics support - ,(list - (concat typescript--name-re "\\s-*" "<\\s-*" typescript--name-start-re) - (list (concat "\\(" typescript--name-re "\\)\\(\\s-*>[^<]*\\)?") - '(backward-char) - '(end-of-line) - '(1 font-lock-type-face))) - - ;; type-highlighting in variable/parameter declarations - ;; supports a small variety of common declarations: - ;; - let a: SomeType; - ;; - private b: SomeType; - ;; - private someFunc(var: SomeType) { - ;; - private array: SomeType[] - ;; - private generic: SomeType<Foo> - ;; - private genericArray: SomeType<Foo>[] - ;; - function testFunc(): SomeType<> { - ;; TODO: namespaced classes! - ,(list - (concat ":\\s-\\(" typescript--type-name-re "\\)\\(<" typescript--type-name-re ">\\)?\\(\[\]\\)?\\([,;]\\)?\\s-*{?") - '(1 'font-lock-type-face)) - - ;; type-casts - ,(list - (concat "<\\(" typescript--type-name-re "\\)>") - '(1 'font-lock-type-face)) - - ;; highlights that append to previous levels - ;; - ,@typescript--font-lock-keywords-3 - - (,typescript--decorator-re (1 font-lock-function-name-face)) - (,typescript--function-call-re (1 font-lock-function-name-face)) - (,typescript--builtin-re (1 font-lock-type-face)) - - ;; arrow function - ("\\(=>\\)" - (1 font-lock-keyword-face))) - "Level four font lock for `typescript-mode'.") - -(defconst typescript--font-lock-keywords - '(typescript--font-lock-keywords-4 typescript--font-lock-keywords-1 - typescript--font-lock-keywords-2 - typescript--font-lock-keywords-3 - typescript--font-lock-keywords-4) - "Font lock keywords for `typescript-mode'. See `font-lock-keywords'.") - -;;; Propertize - -;; -;; The propertize code was adapted from: -;; https://github.com/emacs-mirror/emacs/blob/489d6466372f488adc53897435fff290394b62f7/lisp/progmodes/js.el -;; - -(defconst typescript--syntax-propertize-regexp-regexp - (rx - ;; Start of regexp. - "/" - (0+ (or - ;; Match characters outside of a character class. - (not (any ?\[ ?/ ?\\)) - ;; Match backslash quoted characters. - (and "\\" not-newline) - ;; Match character class. - (and - "[" - (0+ (or - (not (any ?\] ?\\)) - (and "\\" not-newline))) - "]"))) - (group (zero-or-one "/"))) - "Regular expression matching a JavaScript regexp literal.") - -(defun typescript-syntax-propertize-regexp (end) - (let ((ppss (syntax-ppss))) - (when (eq (nth 3 ppss) ?/) - ;; A /.../ regexp. - (goto-char (nth 8 ppss)) - (when (looking-at typescript--syntax-propertize-regexp-regexp) - ;; Don't touch text after END. - (when (> end (match-end 1)) - (setq end (match-end 1))) - (put-text-property (match-beginning 1) end - 'syntax-table (string-to-syntax "\"/")) - (goto-char end))))) - -(defun typescript-syntax-propertize (start end) - ;; JavaScript allows immediate regular expression objects, written /.../. - (funcall - (syntax-propertize-rules - ;; Distinguish /-division from /-regexp chars (and from /-comment-starter). - ;; FIXME: Allow regexps after infix ops like + ... - ;; https://developer.mozilla.org/en/JavaScript/Reference/Operators - ;; We can probably just add +, -, <, >, %, ^, ~, ?, : at which - ;; point I think only * and / would be missing which could also be added, - ;; but need care to avoid affecting the // and */ comment markers. - ("\\(?:^\\|[=([{,:;|&!]\\|\\_<return\\_>\\)\\(?:[ \t]\\)*\\(/\\)[^/*]" - (1 (ignore - (forward-char -1) - (when (or (not (memq (char-after (match-beginning 0)) '(?\s ?\t))) - ;; If the / is at the beginning of line, we have to check - ;; the end of the previous text. - (save-excursion - (goto-char (match-beginning 0)) - (forward-comment (- (point))) - (memq (char-before) - (eval-when-compile (append "=({[,:;" '(nil)))))) - (put-text-property (match-beginning 1) (match-end 1) - 'syntax-table (string-to-syntax "\"/")) - (typescript-syntax-propertize-regexp end))))) - ;; Hash-bang at beginning of buffer. - ("\\`\\(#\\)!" (1 "< b"))) - start end)) - -;;; Indentation - -(defconst typescript--possibly-braceless-keyword-re - (typescript--regexp-opt-symbol - '("catch" "do" "else" "finally" "for" "if" "try" "while" "with")) - "Regexp matching keywords optionally followed by an opening brace.") - -(defconst typescript--indent-keyword-re - (typescript--regexp-opt-symbol '("in" "instanceof")) - "Regexp matching keywords that affect indentation of continued expressions.") - -(defconst typescript--indent-operator-re - (concat "[-+*/%<>=&^|?:.]\\([^-+*/]\\|$\\)\\|" typescript--indent-keyword-re) - "Regexp matching operators that affect indentation of continued expressions.") - -;; -;; We purposely do not allow the plus symbol as a prefix here, as this -;; regex is used to check number literal in type annotations, and TS -;; does not allow to use a plus symbol to prefix numbers there: you -;; can use 1, but not +1 in a type annotation. -;; -;; This is meant to match NaN, floats, decimals, the two infinities -;; and numbers recorded in binary, octal and hex. -;; -;; This regular expression was derived from: -;; https://stackoverflow.com/a/30987109/ -;; -(defconst typescript--number-literal-re - "\\(?:NaN\\|-?\\(?:0[Bb][01]+\\|0[Oo][0-7]+\\|0[Xx][0-9a-fA-F]+\\|Infinity\\|\\(?:[[:digit:]]*\\.[[:digit:]]+\\|[[:digit:]]+\\)\\(?:[Ee][+-]?[[:digit:]]+\\)?\\)\\)" - "Regexp that matches number literals.") - -(defconst typescript--reserved-start-keywords - '("const" "export" "function" "let" "var") - "These keywords cannot be variable or type names and start a new sentence. -Note that the \"import\" keyword can be a type import since TS2.9, so it might -not start a sentence!") - -(defconst typescript--reserved-start-keywords-re - (typescript--regexp-opt-symbol '("const" "export" "function" "let" "var")) - "A regular expression matching `typescript--reserved-start-keywords'.") - -(defconst typescript--type-vs-ternary-re - (concat "[?]\\|" (typescript--regexp-opt-symbol - (append typescript--reserved-start-keywords - '("as" "class" "interface" "private" "public" "readonly")))) - "Keywords/Symbols that help tell apart colon for types vs ternary operators.") - -(defun typescript--search-backward-matching-angle-bracket-inner (depth) - "Auxiliary function for `typescript--search-backward-matching-angle-bracket'. -DEPTH indicates how nested we think we are: it increases when we cross closing -brackets, and decreases when we cross opening brackets." - ;; We look backwards for a "<" that would correspond to the ">" we started - ;; from. However, there is no guarantee that it exists, since our ">" could - ;; be a greater-than operation. Some symbols will make it clear that we are - ;; *not* in a type annotation, so we can return nil. Otherwise, we keep - ;; looking for the matching one. - (or (<= depth 0) - (and - ;; If we cross over a reserved start keyword, we abandon hope of finding - ;; a matching angle bracket. This prevents extreme recursion depths. - (typescript--re-search-backward (concat "[<>]\\|" typescript--reserved-start-keywords-re) nil t) - (cl-case (char-after) - (?< (typescript--search-backward-matching-angle-bracket-inner (- depth 1))) - (?> (typescript--search-backward-matching-angle-bracket-inner (+ depth 1))))))) - -(defun typescript--search-backward-matching-angle-bracket () - "Search for matching \"<\" preceding a starting \">\". -DEPTH indicates how nested we think we are. Assumes the starting position is -right before the closing \">\". Returns nil when a match was not found, -otherwise returns t and the current position is right before the matching -\"<\"." - (typescript--search-backward-matching-angle-bracket-inner 1)) - -(defun typescript--re-search-backward-ignoring-angle-brackets () - "Search backwards, jumping over text within angle brackets. -Searches specifically for any of \"=\", \"}\", and \"type\"." - (and - (typescript--re-search-backward "[>=}]\\|\\_<type\\_>" nil t) - (or (not (looking-at ">")) - (and - (typescript--search-backward-matching-angle-bracket) - (typescript--re-search-backward-ignoring-angle-brackets))))) - -(defun typescript--looking-at-operator-p () - "Return non-nil if point is on a typescript operator, other than a comma." - (save-match-data - (and (looking-at typescript--indent-operator-re) - (or (not (looking-at ":")) - (save-excursion - (backward-sexp) - (and - (typescript--re-search-backward "[?:{]\\|\\_<case\\_>" nil t) - (looking-at "?")))) - ;; Do not identify forward slashes appearing in a "list" as - ;; an operator. The lists are: arrays, or lists of - ;; arguments. In this context, they must be part of regular - ;; expressions, and not math operators. - (not (and (looking-at "/") - (save-excursion - (typescript--backward-syntactic-ws) - (memq (char-before) '(?, ?\[ ?\())))) - ;; Do not identify methods, or fields, that are named "in" or - ;; "instanceof" as being operator keywords. - (not (and - (looking-at typescript--indent-keyword-re) - (save-excursion - (typescript--backward-syntactic-ws) - (memq (char-before) '(?, ?{ ?} ?\;))))) - ;; Do not identify the symbol > if it is likely part of a type argument - ;; T<A>, but identify it if it is likely a greater-than symbol. This is - ;; a hard problem in the absence of semicolons, see: - ;; https://github.com/ananthakumaran/typescript.el/issues/81 - (not (and - (looking-at ">") - (save-excursion - (and - (typescript--search-backward-matching-angle-bracket) - ;; If we made it here, we found a candidate matching opening - ;; angle bracket. We still need to guess whether it actually - ;; is one, and not a spurious less-than operator! - - ;; Look backwards for the first of: - ;; - one of the symbols: = : - ;; - or a TypeScript keyword - ;; Depending on what comes first, we can make an educated - ;; guess on the nature of our ">" of interest. - (typescript--re-search-backward (concat "[=:]\\|" typescript--keyword-re) nil t) - (or - ;; If the previous keyword is "as", definitely a type. - (looking-at "\\_<as\\_>") - ;; Same goes for type imports. - (looking-at "\\_<import\\_>") - ;; A colon could be either a type symbol, or a ternary - ;; operator, try to guess which. - (and (looking-at ":") - (typescript--re-search-backward typescript--type-vs-ternary-re nil t) - (not (looking-at "?"))) - ;; This final check lets us distinguish between a - ;; 2-argument type "t < a , b > ..." and a use of the "," - ;; operator between two comparisons "t < a , b > ...". - ;; Looking back a little more lets us guess. - (and (looking-at "=") - (typescript--re-search-backward-ignoring-angle-brackets) - (looking-at "\\_<type\\_>"))))))) - (not (and - (looking-at "*") - ;; Generator method (possibly using computed property). - (looking-at (concat "\\* *\\(?:\\[\\|" typescript--name-re - " *(\\)")) - (save-excursion - (typescript--backward-syntactic-ws) - ;; We might misindent some expressions that would - ;; return NaN anyway. Shouldn't be a problem. - (memq (char-before) '(?, ?} ?{ ?\;)))))))) - - -(defun typescript--continued-expression-p () - "Return non-nil if the current line continues an expression." - (save-excursion - (back-to-indentation) - (let ((list-start (nth 1 (syntax-ppss)))) - (and - ;; This not clause is there to eliminate degenerate cases where we have - ;; something that looks like a continued expression but we are in fact at - ;; the beginning of the expression. Example: in `if (a) { .q(1)` when the - ;; point is on the dot, the expression that follows looks like a member - ;; expression but the object on which it is a member is missing. If we - ;; naively treat this as a continued expression, we run into trouble - ;; later. (An infinite loop.) - (not (and list-start - (save-excursion - (typescript--backward-syntactic-ws) - (backward-char) - (eq (point) list-start)))) - ;; Don't identify the spread syntax or rest operator as a "continuation". - (not (looking-at "\\.\\.\\.")) - (or (typescript--looking-at-operator-p) - (and (progn - (typescript--backward-syntactic-ws) - (or (bobp) (backward-char)) - (and (> (point) (point-min)) - (save-excursion (backward-char) (not (looking-at "[/*]/"))) - (typescript--looking-at-operator-p) - (and (progn (backward-char) - (not (looking-at "++\\|--\\|/[/*]")))))))))))) - -(cl-defun typescript--compute-member-expression-indent () - "Determine the indent of a member expression. - -This function must be called with point located at the dot that -starts the member expression. -" - ;; Find the line that has the object from which we are getting thismember. - ;; And set an indent relative to that. - (while (looking-at "\\.") - (typescript--backward-syntactic-ws) - (while (eq (char-before) ?\;) - (backward-char)) - (when (memq (char-before) '(?\? ?\!)) - (backward-char)) - (while (memq (char-before) '(?\] ?} ?\) ?>)) - (if (not (eq (char-before) ?>)) - (backward-list) - (backward-char) - (typescript--backward-over-generic-parameter-list)) - (typescript--backward-syntactic-ws)) - (if (looking-back typescript--dotted-name-re nil) - (back-to-indentation) - (typescript--forward-syntactic-ws))) - (+ (current-column) typescript-indent-level)) - -(defun typescript--end-of-do-while-loop-p () - "Return non-nil if point is on the \"while\" of a do-while statement. -Otherwise, return nil. A braceless do-while statement spanning -several lines requires that the start of the loop is indented to -the same column as the current line." - (interactive) - (save-excursion - (save-match-data - (when (looking-at "\\s-*\\_<while\\_>") - (if (save-excursion - (skip-chars-backward "[ \t\n]*}") - (looking-at "[ \t\n]*}")) - (save-excursion - (backward-list) (forward-symbol -1) (looking-at "\\_<do\\_>")) - (typescript--re-search-backward "\\_<do\\_>" (point-at-bol) t) - (or (looking-at "\\_<do\\_>") - (let ((saved-indent (current-indentation))) - (while (and (typescript--re-search-backward "^\\s-*\\_<" nil t) - (/= (current-indentation) saved-indent))) - (and (looking-at "\\s-*\\_<do\\_>") - (not (typescript--re-search-forward - "\\_<while\\_>" (point-at-eol) t)) - (= (current-indentation) saved-indent))))))))) - - -(defun typescript--ctrl-statement-indentation () - "Helper function for `typescript--proper-indentation'. -Return the proper indentation of the current line if it starts -the body of a control statement without braces; otherwise, return -nil." - (save-excursion - (back-to-indentation) - (when (save-excursion - (and (not (eq (point-at-bol) (point-min))) - (not (looking-at "[{]")) - (progn - (typescript--re-search-backward "[[:graph:]]" nil t) - (or (eobp) (forward-char)) - (when (= (char-before) ?\)) (backward-list)) - (skip-syntax-backward " ") - (skip-syntax-backward "w_") - (and - (looking-at typescript--possibly-braceless-keyword-re) - ;; If preceded by period, it's a method call. - (not (= (char-before) ?.)))) - (not (typescript--end-of-do-while-loop-p)))) - (save-excursion - (goto-char (match-beginning 0)) - (+ (current-indentation) typescript-indent-level))))) - -(defun typescript--get-c-offset (symbol anchor) - (let ((c-offsets-alist - (list (cons 'c typescript-comment-lineup-func)))) - (c-get-syntactic-indentation (list (cons symbol anchor))))) - -(defun typescript--backward-over-generic-parameter-list () - "Search backward for the start of a generic's parameter list and move to it. - -This is a utility function for -`typescript--backward-to-parameter-list'. - -This function must be called with the point placed on the final > -of the generic's parameter list. It will scan backwards to find -the start. If successful, it will move the point to the start of -the list. If not, it does not move the point. - -Returns nil on failure, or the position to which the point was -moved on success." - (when (eq (char-after) ?>) - (let ((depth 1)) - (cl-loop named search-loop - while (> depth 0) - do (progn - (unless (re-search-backward "[<>]" nil t) - (cl-return-from search-loop nil)) - (cond - ((looking-at ">") - (unless (eq (char-before) ?=) - (setq depth (1+ depth)))) - ((looking-at "<") (setq depth (1- depth))))) - finally return (point))))) - -(defun typescript--backward-to-parameter-list () - "Search backward for the end of a parameter list and move to it. - -This is a utility function for `typescript--proper-indentation'. - -This function must be called with the point placed before an -opening curly brace. It will try to skip over the type -annotation that would mark the return value of a function and -move to the end of the parameter list. If it is unsuccessful, it -does not move the point. \"Unsuccessful\" here also means that -the position at which we started did not in fact mark the -beginning of a function. The curly brace belonged to some other -syntactic construct than a function. - -Returns nil on failure, or the position to which the point was -moved on success." - (let ((location - (or - ;; This handles the case of a function with return type annotation. - (save-excursion - (cl-loop named search-loop - do - (typescript--backward-syntactic-ws) - ;; Check whether we are at "):". - (when (and (eq (char-before) ?\:) - (progn - (backward-char) - (skip-syntax-backward " ") - (eq (char-before) ?\)))) - ;; Success! This the end of the parameter list. - (cl-return-from search-loop (point))) - ;; If we recognize a structure that belongs in a return type annotation, - ;; skip back over it, or fail. - (cond - ;; Arrow of a function definition, or typeguard (eg. foo is SomeClass) - ((looking-back "=>\\|is" (- (point) 2)) - (backward-char 2)) - ;; End of the parameters list of a generic. - ((eq (char-before) ?>) - (backward-char) - (typescript--backward-over-generic-parameter-list)) - ;; Union of types, or a dot in a dotted name. - ((memq (char-before) '(?| ?.)) - (backward-char)) - ((or - ;; End-delimiter of a delimited construct, for constructs - ;; not handled above. - (memq (char-before) '(?\) ?} ?\" ?\])) - ;; This is also dealing with dotted names. This may come - ;; into play if a jump back moves over an entire dotted - ;; name at once. - ;; - ;; The earlier test for dotted names comes into play if the - ;; logic moves over one part of a dotted name at a time (which - ;; is what `backward-sexp` normally does). - (and (looking-back typescript--dotted-name-re nil) - ;; We don't want the loop to walk over constructs like switch (...) or for (...), etc. - (not (save-excursion - (backward-word) - (looking-at "\\_<\\(switch\\|if\\|while\\|until\\|for\\)\\_>\\(?:\\s-\\|\n\\)*("))))) - (condition-case nil - (backward-sexp) - (scan-error (cl-return-from search-loop nil)))) - ((looking-back typescript--number-literal-re - ;; We limit the search back to the previous space or end of line (if possible) - ;; to prevent the search from going over the whole buffer. - (save-excursion (re-search-backward "\\(?:\\s-\\|\n\\)" nil t)) t) - (goto-char (match-beginning 0))) - ;; Otherwise, we failed to find a location. - (t - (cl-return-from search-loop nil))))) - ;; This handles the case of a function without return type annotation. - (progn - (typescript--backward-syntactic-ws) - (when (eq (char-before) ?\)) - (point)))))) - (when location - (goto-char location)))) - -(defun typescript--proper-indentation (parse-status) - "Return the proper indentation for the current line." - (save-excursion - (back-to-indentation) - (let ((member-expr-p (looking-at "\\."))) - (cond ((nth 4 parse-status) ;; Inside a comment. - (typescript--get-c-offset 'c (nth 8 parse-status))) - ((nth 8 parse-status) 0) ;; Inside a string. - ((typescript--ctrl-statement-indentation)) ;; Control statements. - ((eq (char-after) ?#) 0) ;; Looking at a pragma. - ;; Inside a list of things. Note that in the TS contents, the curly braces - ;; marking code blocks are "list of things". - ((nth 1 parse-status) - (let ((indent-start (point)) - (same-indent-p (looking-at "[]})]")) - (switch-keyword-p (looking-at "\\_<default\\_>\\|\\_<case\\_>[^:]")) - (continued-expr-p (typescript--continued-expression-p)) - (list-start (nth 1 parse-status))) - (goto-char list-start) - (if (looking-at "[({[]\\s-*\\(/[/*]\\|$\\)") - (progn - (skip-syntax-backward " ") - (cond - ((or (typescript--backward-to-parameter-list) - (eq (char-before) ?\))) - ;; Take the curly brace as marking off the body of a function. - ;; In that case, we want the code that follows to see the indentation - ;; that was in effect at the beginning of the function declaration, and thus - ;; we want to move back over the list of function parameters. - (condition-case nil - (backward-list) - (error nil))) - ((looking-back "," nil) - ;; If we get here, we have a comma, spaces and an opening curly brace. (And - ;; (point) is just after the comma.) We don't want to move from the current position - ;; so that object literals in parameter lists are properly indented. - nil) - (t - ;; In all other cases, we don't want to move from the curly brace. - (goto-char list-start))) - (back-to-indentation) - (let* ((in-switch-p (unless same-indent-p - (looking-at "\\_<switch\\_>"))) - (same-indent-p (or same-indent-p - (and switch-keyword-p - in-switch-p))) - (indent - (cond (same-indent-p - (current-column)) - (continued-expr-p - (if (not member-expr-p) - (+ (current-column) (* 2 typescript-indent-level) - typescript-expr-indent-offset) - (goto-char indent-start) - (typescript--compute-member-expression-indent))) - (t - (+ (current-column) typescript-indent-level))))) - (if (and in-switch-p typescript-indent-switch-clauses) - (+ indent typescript-indent-level) - indent))) - (when (and (not same-indent-p) - typescript-indent-list-items) - (forward-char) - (skip-chars-forward " \t")) - (if continued-expr-p - (if (not member-expr-p) - (progn (back-to-indentation) - (+ (current-column) typescript-indent-level - typescript-expr-indent-offset)) - (goto-char indent-start) - (typescript--compute-member-expression-indent)) - (current-column))))) - - ((typescript--continued-expression-p) ;; Inside a continued expression. - (if member-expr-p - (typescript--compute-member-expression-indent) - (+ typescript-indent-level typescript-expr-indent-offset))) - (t 0))))) - -(defun typescript-indent-line () - "Indent the current line as typescript." - (interactive) - (save-restriction - (widen) - (let* ((parse-status - (save-excursion (syntax-ppss (point-at-bol)))) - (offset (- (current-column) (current-indentation)))) - (indent-line-to (typescript--proper-indentation parse-status)) - (when (> offset 0) (move-to-column (+ offset (current-indentation))))))) - -;;; Filling - -(defun typescript-c-fill-paragraph (&optional justify) - "Fill the paragraph with `c-fill-paragraph'." - (interactive "*P") - ;; Dynamically replace functions using the lexically scoped cl-letf. - ;; See below for more details: - ;; http://endlessparentheses.com/understanding-letf-and-how-it-replaces-flet.html - (cl-letf (((symbol-function 'c-forward-sws) - (lambda (&optional limit) - (typescript--forward-syntactic-ws limit))) - ((symbol-function 'c-backward-sws) - (lambda (&optional limit) - (typescript--backward-syntactic-ws limit)))) - (let ((fill-paragraph-function 'c-fill-paragraph)) - (c-fill-paragraph justify)))) - -;; We maintain a cache of semantic information, i.e., the classes and -;; functions we've encountered so far. In order to avoid having to -;; re-parse the buffer on every change, we cache the parse state at -;; each interesting point in the buffer. Each parse state is a -;; modified copy of the previous one, or in the case of the first -;; parse state, the empty state. -;; -;; The parse state itself is just a stack of typescript--pitem -;; instances. It starts off containing one element that is never -;; closed, that is initially typescript--initial-pitem. -;; - - -(defun typescript--pitem-format (pitem) - (let ((name (typescript--pitem-name pitem)) - (type (typescript--pitem-type pitem))) - - (format "name:%S type:%S" - name - (if (atom type) - type - (plist-get type :name))))) - -(defun typescript--make-merged-item (item child name-parts) - "Helper function for `typescript--splice-into-items'. -Return a new item that is the result of merging CHILD into -ITEM. NAME-PARTS is a list of parts of the name of CHILD -that we haven't consumed yet." - (typescript--debug "typescript--make-merged-item: {%s} into {%s}" - (typescript--pitem-format child) - (typescript--pitem-format item)) - - ;; If the item we're merging into isn't a class, make it into one - (unless (consp (typescript--pitem-type item)) - (typescript--debug "typescript--make-merged-item: changing dest into class") - (setq item (make-typescript--pitem - :children (list item) - - ;; Use the child's class-style if it's available - :type (if (atom (typescript--pitem-type child)) - typescript--dummy-class-style - (typescript--pitem-type child)) - - :name (typescript--pitem-strname item)))) - - ;; Now we can merge either a function or a class into a class - (cons (cond - ((cdr name-parts) - (typescript--debug "typescript--make-merged-item: recursing") - ;; if we have more name-parts to go before we get to the - ;; bottom of the class hierarchy, call the merger - ;; recursively - (typescript--splice-into-items (car item) child - (cdr name-parts))) - - ((atom (typescript--pitem-type child)) - (typescript--debug "typescript--make-merged-item: straight merge") - ;; Not merging a class, but something else, so just prepend - ;; it - (cons child (car item))) - - (t - ;; Otherwise, merge the new child's items into those - ;; of the new class - (typescript--debug "typescript--make-merged-item: merging class contents") - (append (car child) (car item)))) - (cdr item))) - -(defun typescript--pitem-strname (pitem) - "Last part of the name of PITEM, as a string or symbol." - (let ((name (typescript--pitem-name pitem))) - (if (consp name) - (car (last name)) - name))) - -(defun typescript--splice-into-items (items child name-parts) - "Splice CHILD into the `typescript--pitem' ITEMS at NAME-PARTS. -If a class doesn't exist in the tree, create it. Return -the new items list. NAME-PARTS is a list of strings given -the broken-down class name of the item to insert." - - (let ((top-name (car name-parts)) - (item-ptr items) - new-items last-new-item new-cons item) - - (typescript--debug "typescript--splice-into-items: name-parts: %S items:%S" - name-parts - (mapcar #'typescript--pitem-name items)) - - (cl-assert (stringp top-name)) - (cl-assert (> (length top-name) 0)) - - ;; If top-name isn't found in items, then we build a copy of items - ;; and throw it away. But that's okay, since most of the time, we - ;; *will* find an instance. - - (while (and item-ptr - (cond ((equal (typescript--pitem-strname (car item-ptr)) top-name) - ;; Okay, we found an entry with the right name. Splice - ;; the merged item into the list... - (setq new-cons (cons (typescript--make-merged-item - (car item-ptr) child - name-parts) - (cdr item-ptr))) - - (if last-new-item - (setcdr last-new-item new-cons) - (setq new-items new-cons)) - - ;; ...and terminate the loop - nil) - - (t - ;; Otherwise, copy the current cons and move onto the - ;; text. This is tricky; we keep track of the tail of - ;; the list that begins with new-items in - ;; last-new-item. - (setq new-cons (cons (car item-ptr) nil)) - (if last-new-item - (setcdr last-new-item new-cons) - (setq new-items new-cons)) - (setq last-new-item new-cons) - - ;; Go to the next cell in items - (setq item-ptr (cdr item-ptr)))))) - - (if item-ptr - ;; Yay! We stopped because we found something, not because - ;; we ran out of items to search. Just return the new - ;; list. - (progn - (typescript--debug "search succeeded: %S" name-parts) - new-items) - - ;; We didn't find anything. If the child is a class and we don't - ;; have any classes to drill down into, just push that class; - ;; otherwise, make a fake class and carry on. - (typescript--debug "search failed: %S" name-parts) - (cons (if (cdr name-parts) - ;; We have name-parts left to process. Make a fake - ;; class for this particular part... - (make-typescript--pitem - ;; ...and recursively digest the rest of the name - :children (typescript--splice-into-items - nil child (cdr name-parts)) - :type typescript--dummy-class-style - :name top-name) - - ;; Otherwise, this is the only name we have, so stick - ;; the item on the front of the list - child) - items)))) - -(defun typescript--pitem-add-child (pitem child) - "Copy `typescript--pitem' PITEM, and push CHILD onto its list of children." - (cl-assert (integerp (typescript--pitem-h-begin child))) - (cl-assert (if (consp (typescript--pitem-name child)) - (cl-loop for part in (typescript--pitem-name child) - always (stringp part)) - t)) - - ;; This trick works because we know (based on our cl-defstructs) that - ;; the child list is always the first element, and so the second - ;; element and beyond can be shared when we make our "copy". - (cons - - (let ((name (typescript--pitem-name child)) - (type (typescript--pitem-type child))) - - (cond ((cdr-safe name) ; true if a list of at least two elements - ;; Use slow path because we need class lookup - (typescript--splice-into-items (car pitem) child name)) - - ((and (consp type) - (plist-get type :prototype)) - - ;; Use slow path because we need class merging. We know - ;; name is a list here because down in - ;; `typescript--ensure-cache', we made sure to only add - ;; class entries with lists for :name - (cl-assert (consp name)) - (typescript--splice-into-items (car pitem) child name)) - - (t - ;; Fast path - (cons child (car pitem))))) - - (cdr pitem))) - -;;; compilation-mode support - -;; tsc supports formatting errors in two general ways: plain and -;; pretty. ("Plain" is our term for "not pretty".) In tsc versions -;; prior to 2.7, the plain and pretty formats both used the same -;; format for references into files. `typescript-tsc-error-regexp` -;; covers both plain and pretty for those versions. -;; -;; Version 2.7 changed the pretty format so as to format source code -;; references differently. This required the introduction of -;; `typescript-tsc-pretty-error-regexp`. The format of plain error -;; messages did not change. So from that version onwards, -;; `typescript-tsc-error-regexp` covers plain error messages and -;; `typescript-tsc-pretty-error-regexp` covers pretty error messages. - -;; handle plain compiler-errors like the following when doing M-x compile<ret>tsc<ret> -;; -;; greeter.ts(24,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -;; greeter.ts(30,12): error TS2339: Property 'indexOf' does not exist on type 'number'. -(defconst typescript-tsc-error-regexp - (concat - "^[[:blank:]]*" - "\\([^(\r\n)]+\\)(\\([0-9]+\\),\\([0-9]+\\)):[[:blank:]]+" - "error [[:alnum:]]+: [^\r\n]+$") - "Regexp to match errors generated by tsc.") - -;; handle pretty compiler-errors like the following when doing M-x compile<ret>tsc<ret> -;; test.ts:2:7 - error TS2322: Type '2' is not assignable to type 'string'. -(defconst typescript-tsc-pretty-error-regexp - (concat - "^[[:blank:]]*" - "\\([^(\r\n)]+\\):\\([0-9]+\\):\\([0-9]+\\) - [[:blank:]]*" - "error [[:alnum:]]+: [^\r\n]+$") - "Regexp to match errors generated by tsc.") - -;; -;; Should handle output like: -;; src/modules/authenticator.ts[1, 83]: ' should be " -;; (quotemarks) src/modules/authenticator.ts[2, 26]: ' should be " -;; ERROR: (quotemarks) src/modules/authenticator.ts[2, 26]: ' should be " -;; WARNING: src/modules/authenticator.ts[2, 26]: ' should be " -;; -;; "(quotemarks)" it the rule name. It is produced when using the -;; "verbose" formatter. The "verbose" formatter is identical to the -;; default ("prose") formatter, except for the additional rule name. -;; -;; "ERROR:" and "WARNING:" are the severity. This was added in tslint -;; 5.0. Prior versions have no notion of severity and simply omit this -;; part. -;; -(defconst typescript-tslint-report-regexp - (concat - "^[[:blank:]]*" - ;; severity ("type" in Emacs' parlance) - "\\(?:\\(?:ERROR\\|\\(WARNING\\)\\):[[:blank:]]+\\)?" - ;; rule name - "\\((.*)[[:blank:]]+\\)?" - ;; filename - "\\([^(\r\n)]+\\)" - "\\[" - ;; line - "\\([[:digit:]]+\\)" - ", " - ;; column - "\\([[:digit:]]+\\)" - "\\]: " - ;; message - ".*$") - "Regexp to match reports generated by tslint.") - -(defconst typescript-nglint-error-regexp - (concat - ;; severity ("type" in Emacs' parlance) - "ERROR:[[:blank:]]+" - - ;; filename - "\\([^(\r\n)]+\\)" - ":" - ;; line - "\\([[:digit:]]+\\)" - ":" - ;; column - "\\([[:digit:]]+\\)" - - " - " - ;; message - ".*$")) - -(defconst typescript-nglint-warning-regexp - (concat - ;; severity ("type" in Emacs' parlance) - "WARNING:[[:blank:]]+" - - ;; filename - "\\([^(\r\n)]+\\)" - ":" - ;; line - "\\([[:digit:]]+\\)" - ":" - ;; column - "\\([[:digit:]]+\\)" - - " - " - ;; message - ".*$")) - -(dolist - (regexp - `((typescript-tsc - ,typescript-tsc-error-regexp - 1 2 3 2) - - (typescript-tsc-pretty - ,typescript-tsc-pretty-error-regexp - 1 2 3 2) - - (typescript-tslint - ,typescript-tslint-report-regexp - 3 4 5 (1)) - - (typescript-nglint-error - ,typescript-nglint-error-regexp - 1 2 3 2) - - (typescript-nglint-warning - ,typescript-nglint-warning-regexp - 1 2 3 1))) - (add-to-list 'compilation-error-regexp-alist-alist regexp) - (add-to-list 'compilation-error-regexp-alist (car regexp))) - -;;; Main Function - -;;;###autoload -(define-derived-mode typescript-mode prog-mode "TypeScript" - "Major mode for editing typescript. - -Key bindings: - -\\{typescript-mode-map}" - - :group 'typescript - :syntax-table typescript-mode-syntax-table - - (setq-local indent-line-function 'typescript-indent-line) - (setq-local beginning-of-defun-function 'typescript-beginning-of-defun) - (setq-local end-of-defun-function 'typescript-end-of-defun) - (setq-local open-paren-in-column-0-is-defun-start nil) - (setq-local font-lock-defaults (list typescript--font-lock-keywords)) - (setq-local syntax-propertize-function #'typescript-syntax-propertize) - (setq-local parse-sexp-ignore-comments t) - (setq-local parse-sexp-lookup-properties t) - - ;; Comments - (setq-local comment-start "// ") - (setq-local comment-end "") - (setq-local fill-paragraph-function 'typescript-c-fill-paragraph) - - ;; Parse cache - (add-hook 'before-change-functions #'typescript--flush-caches t t) - - ;; Frameworks - (typescript--update-quick-match-re) - - ;; for filling, pretend we're cc-mode - (setq c-comment-prefix-regexp "//+\\|\\**" - c-paragraph-start "$" - c-paragraph-separate "$" - c-block-comment-prefix "* " - c-block-comment-ender-regexp "\\*/" - c-line-comment-starter "//" - c-comment-start-regexp "/[*/]\\|\\s!" - comment-start-skip "\\(//+\\|/\\*+\\)\\s *") - - (setq-local electric-indent-chars - (append "{}():;," electric-indent-chars)) - (setq-local electric-layout-rules - '((?\; . after) (?\{ . after) (?\} . before))) - - (let ((c-buffer-is-cc-mode t)) - ;; FIXME: These are normally set by `c-basic-common-init'. Should - ;; we call it instead? (Bug#6071) - (make-local-variable 'paragraph-start) - (make-local-variable 'paragraph-separate) - (make-local-variable 'paragraph-ignore-fill-prefix) - (make-local-variable 'adaptive-fill-mode) - (make-local-variable 'adaptive-fill-regexp) - (c-setup-paragraph-variables)) - - (add-hook 'post-self-insert-hook - #'typescript--post-self-insert-function) - - (setq-local syntax-begin-function #'typescript--syntax-begin-function)) - -;; Set our custom predicate for flyspell prog mode -(put 'typescript-mode 'flyspell-mode-predicate - 'typescript--flyspell-mode-predicate) - -;;;###autoload -(eval-after-load 'folding - '(when (fboundp 'folding-add-to-marks-list) - (folding-add-to-marks-list 'typescript-mode "// {{{" "// }}}" ))) - -;;;###autoload -(add-to-list 'auto-mode-alist '("\\.ts\\'" . typescript-mode)) - -(provide 'typescript-mode) - -;;; typescript-mode.el ends here |