Commit graph

193 commits

Author SHA1 Message Date
Stefan Monnier
1276ba75eb * lisp/progmodes/js.el (js--make-framework-matcher): Use a closure 2021-05-18 20:30:08 -04:00
Lars Ingebrigtsen
1b0dc15a0a Tweak indentation of #foo in js-mode
* lisp/progmodes/js.el (js--proper-indentation): Indent #define
(etc) to column 0, but otherwise indent #foo normally (bug#47488).
2021-05-12 16:17:55 +02:00
Lars Ingebrigtsen
6b7e93e444 Fix indentation of lines starting with # in js-mode
* lisp/progmodes/js.el (js--proper-indentation): # is not like in
C -- it doesn't have to appear on the beginning of the line
(bug#47488).
2021-05-09 11:44:33 +02:00
Matt Beshara
14c9245e82 Remove unnecessary call to message in js.el
* lisp/progmodes/js.el (js--end-of-defun-nested): Remove debugging
message left over (bug#48234).
2021-05-05 14:49:33 +02:00
Stefan Kangas
0a4dc70830 ; Normalize and add missing first and last lines 2021-04-19 12:21:01 +02:00
Stefan Kangas
07bb2cbf55 Don't hard-code "~/.emacs.d/" in two more places
* lisp/gnus/gnus-group.el (gnus-read-ephemeral-bug-group):
* lisp/progmodes/js.el (js-js-tmpdir): Don't hard-code
"~/.emacs.d/".
2021-04-19 09:50:13 +02:00
Basil L. Contovounesios
428339e231 Speed up json.el encoding
This replaces most json-encode-* functions with similar
json--print-* counterparts that insert into the current buffer
instead of returning a string (bug#46761).

Some unused but useful json-encode-* functions are kept for backward
compatibility and as a public API, and the rest are deprecated.

* etc/NEWS: Announce obsoletions.

* lisp/json.el: Document organization of library.  Make subsection
headings more consistent.
(json--encoding-current-indentation): Rename...
(json--print-indentation-prefix): ...to this, to reflect new use.
(json--encode-stringlike, json--encode-alist): Rename...
(json--print-stringlike, json--print-alist): ...to these,
respectively, and encode argument into current buffer instead.  All
callers changed.

(json--print-string, json--print-unordered-map, json--print-array)
(json--print): New functions.
(json-encode-string, json-encode-plist, json-encode-array)
(json-encode): Use them, respectively.

(json-encode-number, json-encode-hash-table): Mark as obsolete
aliases of json-encode.
(json-encode-key, json-encode-list): Mark as obsolete in preference
for json-encode.

(json--print-indentation-depth, json--print-keyval-separator): New
variables.
(json--with-output-to-string): New macro.
(json--print-indentation, json--print-keyword, json--print-key)
(json--print-pair, json--print-map, json--print-list): New
functions.

(json--with-indentation): Use json--print-indentation-depth to avoid
unnecessary string allocation.
(json-encoding-default-indentation, json-pretty-print-max-secs):
Clarify docstrings.
(json--escape, json--long-string-threshold, json--string-buffer):
Remove; no longer used.

* lisp/progmodes/js.el (js--js-encode-value): Replace
json-encode-string and json-encode-number with json-encode.
(js-eval-defun): Use json--print-list to avoid
json-encode-list->insert roundtrip.

* test/lisp/json-tests.el (test-json-encode-number)
(test-json-encode-hash-table, test-json-encode-hash-table-pretty)
(test-json-encode-hash-table-lisp-style)
(test-json-encode-hash-table-sort,  test-json-encode-list):  Replace
uses of obsolete functions with the equivalent use of json-encode.
(test-json-encode-key): Suppress obsoletion warnings.
(test-json-encode-string): Check that text properties are stripped.
2021-03-06 18:25:44 +00:00
Lars Ingebrigtsen
2d43522468 Add "of" as a keyword in js-mode
* lisp/progmodes/js.el (js--keyword-re): Add the "of" of "for
... of" in ECMAScript 2018 (bug#46924).
2021-03-04 21:21:21 +01:00
Stefan Kangas
b4b9ecdfe3 Remove redundant :group args in progmodes/*.el
* lisp/progmodes/bug-reference.el:
* lisp/progmodes/cfengine.el:
* lisp/progmodes/cmacexp.el:
* lisp/progmodes/cpp.el:
* lisp/progmodes/cwarn.el:
* lisp/progmodes/dcl-mode.el:
* lisp/progmodes/executable.el:
* lisp/progmodes/flymake.el:
* lisp/progmodes/gud.el:
* lisp/progmodes/hideshow.el:
* lisp/progmodes/icon.el:
* lisp/progmodes/inf-lisp.el:
* lisp/progmodes/js.el:
* lisp/progmodes/ld-script.el:
* lisp/progmodes/make-mode.el:
* lisp/progmodes/modula2.el:
* lisp/progmodes/pascal.el:
* lisp/progmodes/perl-mode.el:
* lisp/progmodes/prog-mode.el:
* lisp/progmodes/simula.el:
* lisp/progmodes/xscheme.el: Remove redundant :group args.
2021-02-13 07:17:20 +01:00
Stefan Kangas
59e8c37d61 Prefer defvar-local in progmodes/*.el
This skips libraries that might want compatibility with Emacs 24.2.

* lisp/progmodes/compile.el (compilation-auto-jump-to-next)
(compilation--previous-directory-cache, compilation--parsed)
(compilation-gcpro):
* lisp/progmodes/cpp.el (cpp-overlay-list, cpp-edit-buffer)
(cpp-parse-symbols, cpp-edit-symbols):
* lisp/progmodes/ebnf2ps.el (ebnf-eps-upper-x, ebnf-eps-upper-y)
(ebnf-eps-prod-width, ebnf-eps-max-height, ebnf-eps-max-width):
* lisp/progmodes/f90.el (f90-cache-position):
* lisp/progmodes/gud.el (gud-marker-acc):
* lisp/progmodes/js.el (js--quick-match-re)
(js--quick-match-re-func, js--cache-end, js--last-parse-pos)
(js--state-at-last-parse-pos, js--tmp-location):
* lisp/progmodes/octave.el (inferior-octave-directory-tracker-resync):
* lisp/progmodes/sh-script.el (sh-header-marker): Prefer defvar-local.
2021-01-31 20:08:25 +01:00
Paul Eggert
ba05d005e5 Update copyright year to 2021
Run "TZ=UTC0 admin/update-copyright".
2021-01-01 01:13:56 -08:00
Lars Ingebrigtsen
45c1be62a1 Comment JSX lines using JSX syntax
* lisp/progmodes/js.el (js-jsx--comment-region): New function
(bug#41696).
(js-jsx-mode): Use it.
2020-10-22 15:22:05 +02:00
Alan Mackenzie
eae028b9e2 Fix filling in js-mode and mhtml-mode (js-mode parts), fixing bug #41897
* lisp/progmodes/js.el (js-mode): Use "\\(?:" in the value of
comment-start-skip rather than "\\(", fixing the second half of bug #41952.
Call c-foreign-init-lit-pos-cache and install c-foreign-truncate-lit-pos-cache
on before-change-functions, to connect up correctly with CC Mode's filling
mechanism.

* lisp/textmodes/mhtml-mode.el (mhtml--crucial-variable-prefix): Add prefixes
"adaptive-fill-", "fill-", "normal-auto-fill-function" and "paragraph-" to
pull in variables crucial to filling.
(mhtml-syntax-propertize): Read the current submode from the piece of text
being propertized rather than one character before it, and do so before
erasing the submode text-property.
(mhtml-mode): Set the js-mode value of auto-fill-function to js-do-auto-fill.
Correctly initialize and use CC Mode's filling facilities, as above.
2020-07-04 12:55:49 +00:00
Alan Mackenzie
6cb557e7a5 * lisp/progmodes/js.el (js-mode): Remove second call to c-init-language-vars
This spurious second call fouled up already set configuration variables.
Fixes bug #41649.
2020-06-07 15:14:15 +00:00
Paul Eggert
365e01cc9f Update copyright year to 2020
Run "TZ=UTC0 admin/update-copyright $(git ls-files)".
2020-01-01 00:59:52 +00:00
Jackson Ray Hamilton
8e1c553260
Ignore comments and strings when matching JSX
* lisp/progmodes/js.el (js-jsx--matching-close-tag-pos): Ignore
comments and strings.
* test/manual/indent/jsx-comment-string.jsx: New test.
2019-12-07 13:18:00 -08:00
Jackson Ray Hamilton
c299c9b6fb
; * lisp/progmodes/js.el: Fix typo 2019-12-07 13:18:00 -08:00
Jackson Ray Hamilton
3d21ba374f
; * lisp/progmodes/js.el: Remove unnecessary concat 2019-12-07 13:18:00 -08:00
Alan Mackenzie
4ad6c932a8 Add a full set of CC Mode language variables to js.el.
This will allow js.el to work after maintenance changes in CC Mode, e.g. the
fix to bug #11165.

* lisp/progmodes/js.el (top level): Create a CC Mode derived language called
js-mode and based on Java Mode.
(js-mode): call c-init-language-vars for js-mode.  Remove the direct settings
of several CC Mode language variables which are now defined through the
derived language mechanism.  Call c-set-style and set up the needed style
variables c-block-comment-prefix and c-comment-prefix-regexp.
2019-11-06 19:35:43 +00:00
Juanma Barranquero
3ad407005b lisp/*.el, src/*.c: Doc fixes related to returning t vs non-nil
* lisp/progmodes/flymake-proc.el (flymake-proc--find-buffer-for-file):
Doc fix; return value is a buffer, not t.

* lisp/progmodes/ebrowse.el (ebrowse-member-display-p):
Doc fix; return value is the MEMBER argument, not nil.

* lisp/files.el (hack-one-local-variable-eval-safep):
* lisp/play/doctor.el (doctor-nounp, doctor-pronounp):
* lisp/progmodes/flymake-proc.el (flymake-proc--check-include):
* lisp/progmodes/js.el (js--broken-arrow-terminates-line-p):
Doc fix; a non-nil return value is not always t.

* lisp/image.el (image-type-available-p):
* lisp/simple.el (region-active-p):
* lisp/window.el (frame-root-window-p):
* src/buffer.c (Fbuffer_live_p):
* src/image.c (Finit_image_library):
* src/window.c (Fwindow_minibuffer_p):
Doc fix; a non-nil return value is always t.

* doc/lispref/minibuf.texi (Minibuffer Windows): Doc fix.
2019-10-17 02:45:06 +02:00
Robert Pluim
de063da61b Correct some more custom type specs
* lisp/winner.el (winner-boring-buffers-regexp):
* lisp/progmodes/js.el (js-jsx-indent-level):
* lisp/image-dired.el (image-dired-external-viewer):
* lisp/gnus/nnir.el (nnir-notmuch-filter-group-names-function):
Correct custom type specification.

* lisp/textmodes/bibtex.el (bibtex-string-file-path):
(bibtex-file-path): Correct custom type specification and document
source of initial value.
2019-10-11 14:17:08 +02:00
Jackson Ray Hamilton
9aacc443d9
Ignore comments and strings when recognizing JSX
* lisp/progmodes/js.el (js-syntax-propertize): Ignore comments and
strings.
* test/manual/indent/jsx-comment-string.jsx: New test.
2019-09-22 12:55:44 -07:00
Jackson Ray Hamilton
ee89c1cdb5
Make js-jsx-regexps case-sensitive
The regexp in this list used a capitalized “React” because it actually
should be capitalized like that.  Otherwise, the following code would
produce a false positive match: import Thing from './react/Thing'

* lisp/progmodes/js.el (js-jsx-regexps): Update docstring.
(js-jsx--detect-and-enable): Match case-sensitively when determining
whether JSX should be enabled.
2019-09-22 12:03:03 -07:00
Jackson Ray Hamilton
ea09b9fe34
Specify the matching chars for JSX open/close parenthesis
* lisp/progmodes/js.el (js-jsx--syntax-propertize-tag): Indicate the
matching parenthesis character (since JSX’s < and > aren’t typical
parenthesis) for the sake of packages like rainbow-delimiters which
need that information.
2019-06-04 09:05:40 -07:00
Jackson Ray Hamilton
c4214e4dc1
Revert "Add extra text property to fix issue with js2-mode integration"
This reverts commit 382a508ed2.

We ended up deciding against using this in js2-mode.  Instead,
js2-mode may eventually use js-mode’s syntax-propertize-function to
set syntax-table text properties.
2019-06-04 09:05:30 -07:00
Paul Eggert
852d281769 Update author/maintainer info
Update email addresses and fix spellings of some author and
maintainer names.
2019-05-26 01:00:16 -07:00
Jackson Ray Hamilton
382a508ed2
Add extra text property to fix issue with js2-mode integration
* lisp/progmodes/js.el (js-jsx--put-syntax-table): New function for
consistently ensuring smooth js2-mode integration.  js2-mode sets
syntax-table temporarily while parsing buffers—seemingly to recover
from parsing interruptions—and then it later clears syntax-table
blindly.  When integrating with js-mode, this means that unterminated
string quotes are re-broken in JSX (i.e., they become strings again,
often stringifying large regions of the buffer which should not be
strings).  We try to treat quotes in JSXText as non-strings by setting
syntax-table to a non-“string quote” syntax class, but that stops
working if we lose the property.  On the js2-mode end, by scanning for
this second js-jsx-syntax-table property, we can recover the
syntax-table property there.
(js-jsx--text-range, js-jsx--syntax-propertize-tag): Use
js-jsx--put-syntax-table for above reason.
(js-jsx--text-properties): Clear the js-jsx-syntax-table property too.
2019-04-10 22:53:34 -07:00
Jackson Ray Hamilton
f29010729f
Add new defcustom js-jsx-align->-with-<
* lisp/progmodes/js.el (js-jsx-align->-with-<): New variable for users
to control one opinionated aspect of JSX indentation.  It defaults to
the style seen in the React docs, which many users expected as the
“correct” indentation.  Still, the old SGML-style of indentation could
be desirable too, especially since it was the old default.  This
ensures users have a way of getting back the old behavior.
(js-jsx--contextual-indentation): Respect js-jsx-align->-with-<.

* test/manual/indent/jsx-align-gt-with-lt.jsx: New test for
js-jsx-align->-with-<.
2019-04-09 19:42:49 -07:00
Jackson Ray Hamilton
5772971f25
Add new defcustom js-jsx-indent-level
* lisp/progmodes/js.el (js-jsx-indent-level): New variable for users
to set JSX indentation differently than JS, like before.
(js-jsx--contextual-indentation): Respect js-jsx-indent-level when
it’s set.

* test/manual/indent/jsx-indent-level.jsx: New test for
js-jsx-indent-level.
2019-04-09 18:44:36 -07:00
Stefan Monnier
c443133275 * lisp/progmodes/js.el (js-mode): Don't set comment-start-skip globally! 2019-04-09 15:02:00 -04:00
Jackson Ray Hamilton
cf416d96c2
Explain reasonings for JSX syntax support design decisions
* lisp/progmodes/js.el: Throughout the code, provide explanations for
why JSX support was implemented in the way that it was; in particular,
address the overlap between syntax-propertize-function, font-lock, and
indentation (as requested by Stefan).
2019-04-08 22:48:25 -07:00
Jackson Ray Hamilton
7c3ffdaf4b
Move curly functions closer to where they’re used
* lisp/progmodes/js.el (js-jsx--enclosing-curly-pos)
(js-jsx--goto-outermost-enclosing-curly): As the code evolved, these
functions’ definitions ended up being far away from the only places
where they were used.  Move them there.
2019-04-08 22:48:25 -07:00
Jackson Ray Hamilton
9545519572
Add open/close parenthesis syntax to “<” and “>” in JSX
* lisp/progmodes/js.el (js-jsx--syntax-propertize-tag): Like in
sgml-mode, treat “<” and “>” like open/close parenthesis, making the
text more navigable via forward-sexp, etc.
2019-04-08 22:48:25 -07:00
Jackson Ray Hamilton
18bbfc4c75
Permit non-ASCII identifiers in JS
* lisp/progmodes/js.el (js--name-start-re): Generally allow
identifiers to begin with non-ASCII letters.  This is of particular
importance to JSX parsing.

* test/manual/indent/jsx-unclosed-2.jsx: Add test to ensure non-ASCII
characters are parsed properly.
2019-04-08 22:48:24 -07:00
Jackson Ray Hamilton
3eadf1eff4
Identify JSX strings (for js2-mode)
* lisp/progmodes/js.el (js-jsx--syntax-propertize-tag): Derived modes
like js2-mode may use font-lock-syntactic-face-function to apply faces
to JSX strings (and only JSX strings).  Apply the js-jsx-string text
property to such strings so they can be distinctly identified.
(js-jsx--text-properties): Ensure the js-jsx-string text property gets
cleaned up, too.
2019-04-08 22:48:24 -07:00
Jackson Ray Hamilton
e48306f84f
Properly set a dynamic, syntactic mode name
Use mode-line-format constructs to properly set mode-name, rather than
use the very hacky solution that was filling-in for my lack of
knowledge of this feature.

* lisp/progmodes/js.el (js--update-mode-name)
(js--idly-update-mode-name): Remove.

(js--syntactic-mode-name-part): New helper function for mode-name.
(js-use-syntactic-mode-name): Helper to set up the dynamic mode-name.

(js-jsx-enable): Don’t need to call any extra functions now.
(js-mode): Use the new setup function rather than the old ones.

(js-jsx-mode): Use the same initial mode name as js-mode so the final
one is identical for both modes.
2019-04-08 22:48:24 -07:00
Jackson Ray Hamilton
7a9dac5c94
Improve whitespace and unary keyword parsing
* lisp/progmodes/js.el (js--name-start-chars): Remove, adding these
chars back to js--name-start-re.
(js--name-start-re): Add chars back from js--name-start-chars.

(js-jsx--tag-start-re): Improve regexp to capture the tag name (so it
can be disambiguated from a unary keyword), to match newlines (which
are common in this spot), and to require at least one whitespace
character before the attribute name.

(js-jsx--matched-tag-type): Ensure the “tag name” isn’t possibly a
unary keyword.

(js-jsx--self-closing-re, js-jsx--matching-close-tag-pos): Allow
whitespace around “<” and “>”.

* test/manual/indent/jsx-unclosed-2.jsx: Add tests for unary keyword
and whitespace parsing.
2019-04-08 22:48:24 -07:00
Jackson Ray Hamilton
98e36a3e31
Optimize js-jsx--enclosing-tag-pos
* lisp/progmodes/js.el (js-jsx--enclosing-tag-pos): Update docstring
to be more precise.  Also, remember close tag positions after they’ve
been calculated once to avoid many redundant calls to
js-jsx--matching-close-tag-pos.
(js-jsx--text-properties): Ensure js-jsx-close-tag-pos text properties
get cleaned up, too.
2019-04-08 22:48:24 -07:00
Jackson Ray Hamilton
7b2e3c60d0
Optimize js-jsx--matching-close-tag-pos
This function’s performance was having a noticeable impact when
editing large JSX structures.  Improve its performance
slightly (elapsed time will be cut in half according to ELP).

* lisp/progmodes/js.el (js-jsx--tag-re): Remove.
(js-jsx--matched-tag-type): Simplify implementation with respect to
the new implementation of js-jsx--matching-close-tag-pos.
(js-jsx--self-closing-re): Simplify regexp slightly in sync with a
generally simpler matching algorithm.
(js-jsx--matching-close-tag-pos): Optimize matching algorithm by using
multiple simple regexp searches, rather than one big complex search.

* test/manual/indent/jsx-unclosed-2.jsx: Use the term “inequality” and
add a test for a possible parsing foible.
2019-04-08 22:48:24 -07:00
Jackson Ray Hamilton
afec4511cf
Split JSX indentation calculation into several functions
* lisp/progmodes/js.el (js-jsx--contextual-indentation)
(js-jsx--expr-attribute-pos, js-jsx--expr-indentation): Extract logic
from js-jsx--indentation, and improve the logic’s documentation.
(js-jsx--indentation): Simplify by splitting into several
functions (see above) and improve the logic’s documentation.
2019-04-08 22:48:23 -07:00
Jackson Ray Hamilton
55c80d43a9
Indent expressions in JSXAttributes relative to the attribute’s name
* lisp/progmodes/js.el (js-jsx--syntax-propertize-tag): Refer to the
beginning of a JSXExpressionContainer’s associated JSXAttribute (so
line numbers can be calculated later).
(js-jsx--text-properties): Also clear the new text property
js-jsx-expr-attribute.

(js-jsx--indenting): Remove.
(js-jsx--indent-col, js-jsx--indent-attribute-line): New variables.
(js-jsx--indentation): Instead of alternating between two separate
column calculations, neither necessarily correct, bind the JSX column
such that the second call to js--proper-indentation can use it as a
base column.
(js--proper-indentation): Use JSX as the base column for some indents
while indenting JSX.

* test/manual/indent/jsx.jsx: Add more tests for expression indents.
2019-04-08 22:48:23 -07:00
Jackson Ray Hamilton
16669d7c5d
Fix counting of nested self-closing JSXOpeningElements
* lisp/progmodes/js.el (js-jsx--matching-close-tag-pos): Fix bug where
self-closing JSXOpeningElements might be missed if one was nested
within another.

* test/manual/indent/jsx-self-closing.jsx: Add test for bug concerning
self-closing JSXOpeningElement counting.
2019-04-08 22:48:23 -07:00
Jackson Ray Hamilton
84b1cfbc2d
Indent broken arrow function bodies as an N+1th arg
* lisp/progmodes/js.el (js--line-terminating-arrow-re): Revise regexp
for use with re-search-backward.
(js--looking-at-broken-arrow-function-p): Remove.
(js--broken-arrow-terminates-line-p): Replacement for
js--looking-at-broken-arrow-function-p.  Don’t consider whether an
arrow appears at point (in an arglist); instead, just look for an
arrow that terminates the line.
(js--proper-indentation): Use js--broken-arrow-terminates-line-p.

* test/manual/indent/js.js: Add test for a broken arrow as an N+1th
arg.
2019-04-08 22:48:23 -07:00
Jackson Ray Hamilton
8b92719b6b
Improve JSX syntax propertization
* lisp/progmodes/js.el (js-jsx--attribute-name-re): New variable.
(js-jsx--syntax-propertize-tag): Allow “-” in JSXAttribute names.  Fix
“out of range” error when typing at the end of a buffer.  Fix/improve
future propertization of unfinished JSXBoundaryElements.

* test/manual/indent/js-jsx-unclosed-2.js: Add tests for allowed
characters in JSX.
2019-04-08 22:48:22 -07:00
Jackson Ray Hamilton
bf37078df2
Automatically detect JSX in JavaScript files
* lisp/files.el (auto-mode-alist): Simply enable
javascript-mode (js-mode) when opening “.jsx” files, since the “.jsx”
file extension will be used as an indicator of JSX syntax by js-mode,
and more code is likely to work in js-mode than js-jsx-mode, and we
probably want to guide users to use js-mode (with js-jsx-syntax)
instead.  Code that used to work exclusively in js-jsx-mode (if anyone
ever wrote any) ought to be updated to work in js-mode too when
js-jsx-syntax is set to t.

* lisp/progmodes/js.el (js-jsx-detect-syntax, js-jsx-regexps)
(js-jsx--detect-and-enable, js-jsx--detect-after-change): New
variables and functions for detecting and enabling JSX.

(js-jsx-syntax): Update docstring with respect to the widened scope of
the effects and use of this variable.

(js-syntactic-mode-name, js--update-mode-name)
(js--idly-update-mode-name, js-jsx-enable): New variable and functions
for indicating when JSX is enabled.

(js-mode): Detect and enable JSX.  Print all enabled syntaxes after
the mode name whenever Emacs goes idle; this ensures lately-enabled
syntaxes are evident.

(js-jsx-mode): Update mode name for consistency with the state in
which JSX is enabled in js-mode.  Update docstring to suggest
alternative means of using JSX without this mode.  Going forward, it
may be best to gently guide users away from js-jsx-mode, since a “one
mode per syntax extension” model would not scale well if more syntax
extensions were to be simultaneously supported (e.g. Facebook’s
“Flow”).
2019-04-08 22:48:22 -07:00
Jackson Ray Hamilton
339be7c007
Finish replacing SGML-based JSX detection with js-mode’s parsing
This removes the last dependency on sgml-mode for JSX-related logic.

* lisp/progmodes/js.el (js-jsx--start-tag-re)
(js-jsx--end-tag-re): Remove.
(js-jsx--looking-at-start-tag-p)
(js-jsx--looking-back-at-end-tag-p): Reimplement using text
properties, using syntax information which ought to be slightly more
accurate than regexps since it was found by complete parsing.
2019-04-08 22:48:22 -07:00
Jackson Ray Hamilton
1a1ef28518
Indent JSX as parsed in a JS context
Fixes the following issues (and re-fixes indentation issues initially
fixed but later re-broken by previous commits in the process of adding
comprehensive JSX support):

- https://github.com/mooz/js2-mode/issues/389#issuecomment-390766873
- https://github.com/mooz/js2-mode/issues/482
- Bug#32158
- https://github.com/mooz/js2-mode/issues/462

Previously, we delegated to sgml-mode functions for JSX indentation.
However, there were some problems with this approach:

- sgml-mode does not anticipate tags inside attributes when indenting,
  which compromises JSX indentation inside JSXExpressionContainers
  inside JSXAttributes.

- In previous iterations to provide comprehensive JSX support, it
  proved tedious to disambiguate “<” and “>” as JS inequality
  operators and arrow functions from opening and closing angle
  brackets as part of SGML tags.  That code evolved into a more
  complete JSX parsing implementation for syntax-propertize rules for
  font-locking, discarding the superfluous “<”/“>” disambiguation in
  anticipation of using the improved JSX analysis for indentation.

- Using sgml-mode functions, we controlled JSX indentation using SGML
  variables.  However, JSX is a different thing than SGML; referencing
  SGML in JS was a leaky abstraction.

To resolve these issues, use the text properties added by the JSX
syntax-propertize code to determine the boundaries of various aspects
of JSX syntax, and reimplement the sgml-mode indentation code in
js-mode with better respect to JSX indentation conventions.

* lisp/progmodes/js.el (js-jsx-attribute-offset): New variable to
provide a way for users to still control JSX attribute offsets as they
could with sgml-attribute-offset before.  The value of this feature is
dubious IMO, but it’s trivial to keep it, so let’s do it just in case.

(js-jsx--goto-outermost-enclosing-curly): New function.

(js-jsx--enclosing-tag-pos): Refactor to be unbounded by curlies, so
this function can be used to find JSXExpressionContainers within JSX.
Fix bug where an enclosing JSXElement couldn’t be found when point was
at the start of its JSXClosingElement.  Return the JSXClosingElement’s
position as well, so the JSXClosingElement can be indentified when
indenting and be indented like the matching JSXOpeningElement.

(js-jsx--at-enclosing-tag-child-p): js-jsx--enclosing-tag-pos now
returns a list rather than a cons, so retrieve the JSXOpeningElement’s
end position from a list.

(js-jsx--context, js-jsx--indenting): New function and variable.
(js-jsx--indentation): New function replacing the prior
js-jsx--indent* functions and js-jsx-indent-line’s implementation.
Use the JSX parsing performed in a JS context to more accurately
calculate JSX indentation than by delegating to sgml-mode functions.
(js--proper-indentation): Use js-jsx--indentation as yet another type
of indentation.
(js-jsx--as-sgml, js-jsx--outermost-enclosing-tag-pos)
(js-jsx--indentation-type, js-jsx--indent-line-in-expression)
(js-jsx--indent-n+1th-line): Remove obsolete functions.

(js-jsx-indent-line): Refactor nearly-obsolete function to behave the
same as it usually would before these changes, without respect to the
binding of js-jsx-syntax.

(js-jsx-mode): Remove obsolete documentation about the use of SGML
variables to control indentation, and don’t bind indent-line-function
any more, because it is no longer necessary given the new
implementation of js-jsx-indent-line.
2019-04-08 22:48:22 -07:00
Jackson Ray Hamilton
8dae74236d
Propertize and font-lock JSXText and JSXExpressionContainers
This completes highlighting support for JSX, as requested in:

- https://github.com/mooz/js2-mode/issues/140
- https://github.com/mooz/js2-mode/issues/330
- https://github.com/mooz/js2-mode/issues/409

* lisp/progmodes/js.el (js--name-start-chars): Extract part of
js--name-start-re so it can be reused in another regexp.
(js--name-start-re): Use js--name-start-chars.

(js-jsx--font-lock-keywords): Use new matchers.
(js-jsx--match-text, js-jsx--match-expr): New matchers to remove
typical JS font-locking and extend the font-locked region,
respectively.

(js-jsx--tag-re, js-jsx--self-closing-re): New regexps matching JSX.
(js-jsx--matched-tag-type, js-jsx--matching-close-tag-pos)
(js-jsx--enclosing-curly-pos, js-jsx--enclosing-tag-pos)
(js-jsx--at-enclosing-tag-child-p): New functions for parsing and
analyzing JSX.

(js-jsx--text-range, js-jsx--syntax-propertize-tag-text): New
functions for propertizing JSXText.
(js-jsx--syntax-propertize-tag): Propertize JSXText children of tags.
(js-jsx--text-properties): Remove JSXText-related text properties when
repropertizing.
(js-mode): Extend the syntax-propertize region with
syntax-propertize-multiline; we are now adding the syntax-multiline
text property to buffer ranges that are JSXText to ensure the whole
multiline JSX construct is reidentified.
2019-04-08 22:48:21 -07:00
Jackson Ray Hamilton
4d2b5bbfeb
Font-lock JSX while editing it by extending regions
* lisp/progmodes/js.el (js-jsx--font-lock-keywords):
Call tag beginning and end matchers.
(js-jsx--match-tag-beg, js-jsx--match-tag-end): New functions.
(js-jsx--syntax-propertize-tag): Record buffer positions of JSXElement
beginning and end for font-locking.

(js--syntax-propertize-extend-region)
(js-jsx--syntax-propertize-extend-region): New functions for extending
the syntax-propertize region backwards to the start of a JSXElement so
its JSXAttribute children on its n+1th lines can be parsed as such
while editing those lines.
(js-mode): Add js--syntax-propertize-extend-region to
syntax-propertize-extend-region-functions.
2019-04-08 22:48:21 -07:00
Jackson Ray Hamilton
52a3113b9b
Add basic JSX font-locking
Font-lock JSX from the beginning of the buffer to the end.  Tends to
break temporarily when editing lines, because the parser doesn’t yet
look backwards to determine if the end of a tag in the current range
starts before the range.

This also re-breaks some tests fixed by previous commits, as we begin
to take a different direction in our parsing code, looking for JSX,
rather than for non-JSX.  The parsing code will eventually provide
information for indentation again.

* lisp/progmodes/js.el (js--dotted-captured-name-re)
(js-jsx--disambiguate-beginning-of-tag)
(js-jsx--disambiguate-end-of-tag, js-jsx--disambiguate-syntax):
Remove.
(js-jsx--font-lock-keywords): New variable.
(js--font-lock-keywords-3): Add JSX matchers.
(js-jsx--match-tag-name, js-jsx--match-attribute-name): New functions.
(js-jsx--syntax-propertize-tag): New function to aid in JSX
font-locking and eventually indentation.
(js-jsx--text-properties): New variable.
(js-syntax-propertize): Propertize JSX properly using
syntax-propertize-rules.
2019-04-08 22:48:21 -07:00