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, 2988 insertions, 0 deletions
diff --git a/elpa/typescript-mode-20220506.827/typescript-mode.el b/elpa/typescript-mode-20220506.827/typescript-mode.el new file mode 100644 index 0000000..220cf75 --- /dev/null +++ b/elpa/typescript-mode-20220506.827/typescript-mode.el @@ -0,0 +1,2988 @@ +;;; 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 |