Mercurial > hg > dotemacs
changeset 193:523ffc74c020
js2-mode: grab it from external packages
line wrap: on
line diff
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219.signed @@ -0,0 +1,1 @@ +Good signature from 474F05837FBDEF9B GNU ELPA Signing Agent <elpasign@elpa.gnu.org> (trust undefined) created at 2019-02-19T17:10:03-0500 using DSA \ No newline at end of file
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/.dir-locals.el @@ -0,0 +1,1 @@ +((nil . ((sentence-end-double-space . t))))
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/.elpaignore @@ -0,0 +1,4 @@ +.travis.yml +.gitignore +Makefile +tests
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/.travis.yml @@ -0,0 +1,24 @@ +# https://github.com/rolandwalker/emacs-travis + +language: emacs-lisp + +env: + matrix: + - EMACS=emacs24 + - EMACS=emacs-snapshot + +install: + - if [ "$EMACS" = "emacs24" ]; then + sudo add-apt-repository -y ppa:cassou/emacs && + sudo apt-get update -qq && + sudo apt-get install -qq emacs24 emacs24-el; + fi + - if [ "$EMACS" = "emacs-snapshot" ]; then + sudo add-apt-repository -y ppa:cassou/emacs && + sudo apt-get update -qq && + sudo apt-get install -qq emacs-snapshot && + sudo apt-get install -qq emacs-snapshot-el emacs-snapshot-gtk; + fi + +script: + make test EMACS=${EMACS}
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/ChangeLog @@ -0,0 +1,196 @@ +2019-02-19 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit 'ed955e7f1608cfd2d2713129d65f5fd734842ae4' from js2-mode + +2018-03-01 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '38e425785d5ea4600c3642f6500062ecedf694a4' from js2-mode + +2017-07-21 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit 'cb57d9b67390ae3ff70ab64169bbc4f1264244bc' from js2-mode + +2017-01-16 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '03c679eb9914d58d7d9b7afc2036c482a9a01236' from js2-mode + +2016-07-11 Paul Eggert <eggert@cs.ucla.edu> + + Fix some quoting problems in doc strings + + Most of these are minor issues involving, e.g., quoting `like this' + instead of 'like this'. A few involve escaping ` and ' with a preceding + \= when the characters should not be turned into curved single quotes. + +2016-06-23 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '0cda39255827f283e7578cd469ae42daad9556a2' from js2-mode + +2016-01-21 Stefan Monnier <monnier@iro.umontreal.ca> + + * packages/gnome-c-style/gnome-c-tests.el: Add copyright blurb + +2015-09-09 Dmitry Gutov <dgutov@yandex.ru> + + Undo some breakage + +2015-09-09 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '5c9d8b82dddec2fab370ec8798569c7fc5698093' from js2-mode + +2015-07-18 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '494c421bfa6f1b72b577267cb3841b0eff262250' from js2-mode + +2015-07-13 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit 'f3a899bb1c36e25e078eed2890eb2fecb22f4175' from js2-mode + +2015-04-24 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit 'ac93b9eef9b6ac44d187b9688d68a7a5f205b3fe' from js2-mode + + Conflicts: + packages/js2-mode/js2-mode.el + +2015-04-15 Stefan Monnier <monnier@iro.umontreal.ca> + + * js2-mode.el (js2-mode): Use cursor-sensor-mode if available. + + (js2-export-node): Fix apparent paren typo. + (js2-get-token-internal-1): Remove unused var `quote-char'. + (js2-clear-face): Also remove cursor-sensor-functions. + (js2-parse-primary-expr): Remove unused var `pn'. + (js2-parse-legacy-array-comp): Remove unused var `first'. + (js2-mode-show-node, js2-mode-show-warn-or-err): Use + cursor-sensor-functions if available. + (js2-mode-hide-overlay, js2-echo-error): Adapt to new calling + convention. + (js2-echo-help): Declare obsolete. + (js2-mode-extend-comment): Look for the appropriate property. + +2015-02-02 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '7558a961a03b3a9d26fafc69d9665e4aadf47738' from js2-mode + +2014-11-18 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '3abcd90ddc2f446ddf0fb874dd79ba870c26ad2d' from js2-mode + +2014-11-15 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '2c744815cf9e4653625dd25f2e7f8b59c152782d' from js2-mode + + Conflicts: + packages/js2-mode/js2-imenu-extras.el + +2014-10-15 Stefan Monnier <monnier@iro.umontreal.ca> + + * packages/js2-mode/js2-imenu-extras.el: Use Unix-style EOL. + +2014-01-14 Dmitry Gutov <dgutov@yandex.ru> + + Merge commit '3575aaa39f311822dcedd53235ba036e9cf68ab8' from js2-mode + +2013-11-07 Stefan Monnier <monnier@iro.umontreal.ca> + + * js2-mode/tests: Add copyright headers. + +2013-11-06 Dmitry Gutov <dgutov@yandex.ru> + + Merge remote-tracking branch 'js2-mode/master' + +2013-10-06 Dmitry Gutov <dgutov@yandex.ru> + + Add packages/js2-mode/.elpaignore + +2013-08-21 Stefan Monnier <monnier@iro.umontreal.ca> + + Sync from js2-mode/master + +2013-08-20 Stefan Monnier <monnier@iro.umontreal.ca> + + * packages/js2-mode/js2-mode.el: Remove unused variables. Use posix + character classes. Do a bit of CSE simplification. + (js2-parse-highlight-member-expr-node): Flip test order to simplify + code. + (js2-re-search-forward, js2-re-search-backward): Don't quote code. + (js2-echo-help): Defalias applies to symbol, not functions. + +2013-08-15 Stefan Monnier <monnier@iro.umontreal.ca> + + Fix up copyrights and the checking code + +2013-08-15 Stefan Monnier <monnier@iro.umontreal.ca> + + Mark merge point of js2-mode. + +2013-06-19 Dmitry Gutov <dgutov@yandex.ru> + + js2-mode: Merge from upstream + + Git commit 714dca50644c75884d9d90f10328c7a12e02cdcc + +2013-06-08 Dmitry Gutov <dgutov@yandex.ru> + + js2-mode: Merge from upstream + + Git commit 1c53de75e0acd19d61ad45a91b32c183948e5128 + +2013-05-10 Dmitry Gutov <dgutov@yandex.ru> + + js2-mode: Fix a typo + + Git commit c50f3d1d9db63bcbea3f02036ee17ab0d7511be0 + +2013-05-10 Dmitry Gutov <dgutov@yandex.ru> + + js2-mode: Merge from upstream + + * js2-imenu-extras: New file. + + Git commit 3c69aea0c267e7bbadd5e35eb6cab54764c9d91c + +2013-03-07 Dmitry Gutov <dgutov@yandex.ru> + + js2-mode: Merge from upstream (js2-multiline-decl-indentation) + +2013-02-28 Dmitry Gutov <dgutov@yandex.ru> + + js2-mode: Merge from upstream + +2013-02-19 Dmitry Gutov <dgutov@yandex.ru> + + js2-mode: Use \\' instead of $ + +2013-02-19 Dmitry Gutov <dgutov@yandex.ru> + + Merge from upstream + +2013-02-17 Dmitry Gutov <dgutov@yandex.ru> + + Merge from upstream + +2012-12-26 Dmitry Gutov <dgutov@yandex.ru> + + * js2-mode: same for Returns -> Return + +2012-12-26 Dmitry Gutov <dgutov@yandex.ru> + + Re-apply the Toggles -> Toggle wording change + +2012-12-25 Dmitry Gutov <dgutov@yandex.ru> + + * js2-mode: merge from upstream + + Lots of small changes, too many to enumerate. + +2012-10-31 Stefan Monnier <monnier@iro.umontreal.ca> + + * admin/update-archive.sh: Keep old packages. + +2011-07-01 Chong Yidong <cyd@stupidchicken.com> + + Give every package its own directory in packages/ including single-file + packages. +
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + 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/>. + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + <program> Copyright (C) <year> <name of author> + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +<http://www.gnu.org/licenses/>. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +<http://www.gnu.org/philosophy/why-not-lgpl.html>.
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/Makefile @@ -0,0 +1,23 @@ +# -*- Makefile -*- + +EMACS = emacs + +# Compile with noninteractive and relatively clean environment. +BATCHFLAGS = -batch -Q + +SRCS = js2-mode.el js2-imenu-extras.el + +OBJS = $(SRCS:.el=.elc) + +%.elc: %.el + ${EMACS} $(BATCHFLAGS) -L . -f batch-byte-compile $^ + +all: $(OBJS) + +clean: + -rm -f $(OBJS) + +test: + ${EMACS} $(BATCHFLAGS) -L . -l js2-mode.el -l js2-old-indent.el -l tests/parser.el \ + -l tests/indent.el -l tests/externs.el -l tests/json-path.el -l tests/consume.el \ + -l tests/navigation.el -f ert-run-tests-batch-and-exit
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/NEWS.md @@ -0,0 +1,265 @@ +# History of user-visible changes + +## 2019-02-19 + +* Changed the default of `js2-strict-trailing-comma-warning` to nil. + +## 2018-03-01 + +* Support single-line JSDocs. +* New face `js2-object-property-access`. +* Support for trailing comma in function arguments +* JSDoc highlighting for `@yield`, `@yields`, `@abstract`, `@virtual` and `@typedef`. +* Support for anonymous class exports. + +## 2017-07-21 + +* Support for async arrow function without parentheses. +* Support for `/*jslint` declarations. +* User option `js2-getprop-has-side-effects`. +* Support for trailing commas in function parameter lists. +* Support for ES7 public class fields. +* New user option `js2-ignored-warnings`. + +## 2017-01-16 + +* `js2-include-*-externs` are now evaluated on demand. As a result, + they can now be effectively used as file- or directory-local + variables. +* Support for ES7 exponentiation operator. + +## 2016-06-23 + +* New variable `js2-mode-assume-strict`, for use with ES6 modules. +* Support for JSDoc @callback, @func and @method tags. +* Object properties are highlighted using a different face: + `js2-object-property`, which has no color by default. +* Experimental support for object rest/spread ECMAScript proposal. +* `js2-getter-setter-node` is renamed to `js2-method-node`, together with + its related functions. It already handles generator methods, and we + added support for async methods (see below), so the old name would get + more confusing. +* Support for default parameters in destructuring. It should work for both + objects and arrays, in both literals and function arguments. +* New mode: `js2-jsx-mode`, deriving from `js2-mode`. Supports indentation of + JSXElement expressions wrapped within parentheses or as function arguments. + Indentation is customizable via `sgml-attribute-offset`. +* Experimental support for async/await ECMAScript proposal. + +## 20150909 + +* `js2-mode` now derives from `js-mode`. That means the former + function will run `js-mode-hook`, as well as `js2-mode-hook`. The + key bindings will default to `js-mode-map` where they're not set in + `js2-mode-map`. And in Emacs 25 or later (including the snapshot + builds), `js2-mode` uses the indentation code from `js-mode`. Where + feasible, the user options (and functions) now have aliases, but if + you're using Emacs 25 and you see an indentation-related setting + that stopped working, try looking for a corresponding one in the + `js` group: `M-x customize-group RET js RET`. + +* New command: `js2-jump-to-definition`. It's bound to `M-.` by + default, via remapping `js-find-symbol`. To get back to the default + `M-.` binding (e.g. `find-tag`), put this in your init file: + + (eval-after-load 'js (define-key js-mode-map (kbd "M-.") nil)) + +## 20150713 + +* More comprehensive strict mode warnings and syntax errors. +* New minor mode: `js2-highlight-unused-variables-mode`. +* `js2-pretty-multiline-declarations` can take the value `dynamic` now. + +## 20150202 + +Support for: + +* [ES6 modules](http://www.2ality.com/2014/09/es6-modules-final.html). +* [Short-hand object literals](http://ariya.ofilabs.com/2013/02/es6-and-object-literal-property-value-shorthand.html). +* [Method definitions](http://ariya.ofilabs.com/2013/03/es6-and-method-definitions.html). +* ['u' and 'y' RegExp flags](https://mathiasbynens.be/notes/es6-unicode-regex). +* [Computed property names](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-object-initializer). +* [Class statements and expressions](https://github.com/lukehoban/es6features#classes). +* [Template strings](http://tc39wiki.calculist.org/es6/template-strings/), including tagged ones. + +The variable `js2-allow-keywords-as-property-names` has been +removed. Instead we check if `js2-language-version` is 180 or highter. + +## 20141115 + +Support for: + +* Unicode characters in identifiers (improved). +* [Delegating yield](http://wiki.ecmascript.org/doku.php?id=harmony:generators#delegating_yield). +* [ES6 numeric literals](https://people.mozilla.org/~jorendorff/es6-draft.html#sec-literals-numeric-literals) (octal, binary). +* Harmony [array and generator comprehensions](http://wingolog.org/archives/2014/03/07/es6-generator-and-array-comprehensions-in-spidermonkey). + +## 20131106 + +Support for: + +* [Arrow functions](http://wiki.ecmascript.org/doku.php?id=harmony:arrow_function_syntax) +* [Generators](http://wiki.ecmascript.org/doku.php?id=harmony:generators) +* [Spread operator](http://wiki.ecmascript.org/doku.php?id=harmony:spread) + +## 20130510 + +### Support for JSLint global declaration + +See the docstring for `js2-include-jslint-globals`. + +## 20130216 + +### We don't rebind `RET` anymore + +Because well-behaving major modes aren't supposed to do that. + +So pressing it won't continue a block comment, or turn a string into a concatenation. +Pressing `M-j`, however, will. + +The options `js2-indent-on-enter-key` and `js2-enter-indents-newline` were also removed. + +To bring back the previous behavior, put this in your init file: + +```js +(eval-after-load 'js2-mode + '(define-key js2-mode-map (kbd "RET") 'js2-line-break)) +``` + +## 20120617 + +### Support for [default](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/default_parameters) and [rest](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/rest_parameters) parameters + +## 20120614 + +### Support for [for..of loops](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of) + +## Older changes + +### Popular indentation style + +```js +[foo, bar, baz].forEach(function (v) { + if (validate(v)) + process(v); +}); + +[a, b, c].some(function (v) { + return validate(v); +}); +``` + +### Pretty multiline variable declaration + +In the original mode, + +```js +var foo = 10, +bar = 20, +baz = 30; +``` + +In this mode when the value of `js2-pretty-multiline-declarations` is non-nil, + +```js +var foo = 10, + bar = 20, + baz = 30; +``` + +### Abbreviated destructuring assignments + +```js +let {a, b} = {a: 10, b: 20}; // Abbreviated (Not supported in the original mode) +let {a: a, b: b} = {a: 10, b: 20}; // Same as above (Supported in the original mode) + +(function ({responseText}) { /* */ })(xhr); // As the argument of function + +for (let [k, { name, age }] in Iterator(obj)) // nested + print(k, name, age); +``` + +### Expression closure in property value + +```js +let worker = { + get age() 20, + get sex() "male", + fire: function () _fire() +}; +``` + +### Fix for odd indentation of "else if" with no braces + +In the original mode, + +```js +if (foo) + return foo; +else if (bar) +return bar; // here +``` + +In this mode, + +```js +if (foo) + return foo; +else if (bar) + return bar; // fixed +``` + +### Imenu support for function nesting + +Supports function nesting and anonymous wrappers: + +```js +(function() { + var foo = function() { + function bar() { // shown as foo.bar.<definition-1> + function baz() {} // foo.bar.baz + var qux = function() {}; // foo.bar.quux + } + }; +}); +``` + +Examples of output: + +* [jQuery 1.5](https://gist.github.com/845449) +* [Underscore.js](https://gist.github.com/824262) +* [Backbone.js](https://gist.github.com/824260) + +For library-specific extension methods like `$.extend` and `dojo.declare`, see [js2-imenu-extras](/mooz/js2-mode/blob/master/js2-imenu-extras.el). + +### Undeclared/external variables highlighting + +Original mode highlights them only on the left side of assignments: + +```js +var house; +hose = new House(); // highlights "hose" +``` + +Here they are highlighted in all expressions: + +```js +function feed(fishes, food) { + for each (var fish in fshes) { // highlights "fshes" + food.feed(fsh); // highlights "fsh" + } + hood.discard(); // highlights "hood" +} +``` + +Destructuring assignments and array comprehensions (JS 1.7) are supported: + +```js +let three, [one, two] = [1, 2]; +thee = one + two; // highlights "thee" + +function revenue(goods) { + // highlights "coast" + return [price - coast for each ({price, cost} in goods)].reduce(add); +} +```
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/README.md @@ -0,0 +1,58 @@ +About [](https://travis-ci.org/mooz/js2-mode) [](https://melpa.org/#/js2-mode) +====== + +Improved JavaScript editing mode for GNU Emacs ([description here](http://elpa.gnu.org/packages/js2-mode.html)). + +For some of the latest changes, see [latest user-visible changes](https://github.com/mooz/js2-mode/blob/master/NEWS.md). + +Installation +====== + +The stable versions are hosted at [GNU ELPA](http://elpa.gnu.org/) +(<kbd>M-x list-packages</kbd>). + +You can also install the latest development version from +[MELPA](https://melpa.org/#/getting-started). + +Emacs 22 and 23 +=============== + +This version requires Emacs 24 and `cl-lib` (either built-in or from GNU ELPA above). +For a backward compatible version, check out the branch +[emacs23](https://github.com/mooz/js2-mode/tree/emacs23). + +Bugs +==== + +* See broken syntax highlighting and timer errors? Recently upgraded +Emacs from version 24.2 or earlier? Try +[reinstalling or byte-recompiling](https://github.com/mooz/js2-mode/issues/72) +the package. + +* Any indentation problems should be reported with `M-x report-emacs-bug` +(please try reproducing them with `js-mode` first, for clarity). +Starting with Emacs 25, `js2-mode` delegates indentation to +the indentation engine of `js-mode`. + +Please report other problems at <http://github.com/mooz/js2-mode/issues>. + +Contributing +====== + +`js2-mode` is subject to the same +[copyright assignment](http://www.gnu.org/prep/maintain/html_node/Copyright-Papers.html) +policy as Emacs itself, `org-mode`, `CEDET` and other packages in +[GNU ELPA](http://elpa.gnu.org/packages/). + +Any +[legally significant](http://www.gnu.org/prep/maintain/html_node/Legally-Significant.html#Legally-Significant) +contributions can only be accepted after the author has completed their +paperwork. Please ask for the request form, and we'll send it to you. + +See Also +====== + +Some third-party modes that use the generated syntax tree: + +* [js2-refactor](https://github.com/magnars/js2-refactor.el) +* [skewer-mode](https://github.com/skeeto/skewer-mode)
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/js2-imenu-extras.el @@ -0,0 +1,349 @@ +;;; js2-imenu-extras.el --- Imenu support for additional constructs + +;; Copyright (C) 2012-2014 Free Software Foundation, Inc. + +;; Author: Dmitry Gutov <dgutov@yandex.ru> +;; Keywords: languages, javascript, imenu + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Commentary: + +;; This package adds Imenu support for additional framework constructs and +;; structural patterns to `js2-mode'. + +;; Usage: + +;; (add-hook 'js2-mode-hook 'js2-imenu-extras-mode) + +;; To customize how it works: +;; M-x customize-group RET js2-imenu RET + +(eval-when-compile + (require 'cl)) + +(require 'js2-mode) + +(defvar js2-imenu-extension-styles + `((:framework jquery + :call-re "\\_<\\(?:jQuery\\|\\$\\|_\\)\\.extend\\s-*(" + :recorder js2-imenu-record-jquery-extend) + + (:framework jquery-ui + :call-re "^\\s-*\\(?:jQuery\\|\\$\\)\\.widget\\s-*(" + :recorder js2-imenu-record-string-declare) + + (:framework dojo + :call-re "^\\s-*dojo.declare\\s-*(" + :recorder js2-imenu-record-string-declare) + + (:framework backbone + :call-re ,(concat "\\_<" js2-mode-identifier-re "\\.extend\\s-*(") + :recorder js2-imenu-record-backbone-extend) + + (:framework enyo + :call-re "\\_<enyo\\.kind\\s-*(" + :recorder js2-imenu-record-enyo-kind) + + (:framework react + :call-re "\\_<React\\.createClass\\s-*(" + :recorder js2-imenu-record-react-class) + + (:framework sencha + :call-re "^\\s-*Ext\\.define\\s-*(" + :recorder js2-imenu-record-sencha-class)) + "List of JavaScript class definition or extension styles. + +:framework is a valid value in `js2-imenu-enabled-frameworks'. + +:call-re is a regular expression that has no capturing groups. + +:recorder is a function name that will be called when the regular +expression matches some text in the buffer. When it's called, point will be +at the end of the match. The function must keep the point position.") + +(defconst js2-imenu-available-frameworks + (mapcar (lambda (style) (plist-get style :framework)) js2-imenu-extension-styles) + "List of available JavaScript framework symbols.") + +(defcustom js2-imenu-enabled-frameworks js2-imenu-available-frameworks + "Frameworks to be recognized by `js2-mode'." + :type (cons 'set (mapcar (lambda (x) (list 'const x)) + js2-imenu-available-frameworks)) + :group 'js2-imenu) + +(defcustom js2-imenu-show-other-functions t + "Non-nil to show functions not recognized by other mechanisms, +in a shared namespace." + :type 'boolean + :group 'js2-imenu) + +(defcustom js2-imenu-other-functions-ns "?" + "Namespace name to use for other functions." + :type 'string + :group 'js2-imenu) + +(defcustom js2-imenu-show-module-pattern t + "Non-nil to recognize the module pattern: + +var foobs = (function(a) { + return {fib: function() {}, fub: function() {}}; +})(b); + +We record the returned hash as belonging to the named module, and +prefix any functions defined inside the IIFE with the module name." + :type 'boolean + :group 'js2-imenu) + +(defcustom js2-imenu-split-string-identifiers t + "When non-nil, split string identifiers on dots. +Currently used for jQuery widgets, Dojo and Enyo declarations." + :type 'boolean + :group 'js2-imenu) + +;;;###autoload +(defun js2-imenu-extras-setup () + (when js2-imenu-enabled-frameworks + (add-hook 'js2-build-imenu-callbacks 'js2-imenu-record-declarations t t)) + (when (or js2-imenu-show-other-functions js2-imenu-show-module-pattern) + (add-hook 'js2-build-imenu-callbacks 'js2-imenu-walk-ast t t))) + +(defun js2-imenu-extras-remove () + (remove-hook 'js2-build-imenu-callbacks 'js2-imenu-record-declarations t) + (remove-hook 'js2-build-imenu-callbacks 'js2-imenu-walk-ast t)) + +(defun js2-imenu-record-declarations () + (let* ((styles (loop for style in js2-imenu-extension-styles + when (memq (plist-get style :framework) + js2-imenu-enabled-frameworks) + collect style)) + (re (mapconcat (lambda (style) + (concat "\\(" (plist-get style :call-re) "\\)")) + styles "\\|"))) + (goto-char (point-min)) + (while (js2-re-search-forward re nil t) + (loop for i from 0 to (1- (length styles)) + when (match-beginning (1+ i)) + return (funcall (plist-get (nth i styles) :recorder)))))) + +(defun js2-imenu-record-jquery-extend () + (let ((pred (lambda (subject) + (and + (js2-prop-get-node-p subject) + (string= (js2-name-node-name (js2-prop-get-node-right subject)) + "prototype"))))) + (js2-imenu-record-extend-first-arg (1- (point)) pred + 'js2-compute-nested-prop-get))) + +(defun js2-imenu-record-string-declare () + (js2-imenu-record-extend-first-arg + (1- (point)) 'js2-string-node-p + (lambda (node) + (if js2-imenu-split-string-identifiers + (split-string (js2-string-node-value node) "\\." t) + (list (js2-string-node-value node)))))) + +(defun js2-imenu-record-extend-first-arg (point pred qname-fn) + (let* ((node (js2-node-at-point point)) + (args (js2-call-node-args node)) + (subject (first args))) + (when (funcall pred subject) + (loop for arg in (cdr args) + when (js2-object-node-p arg) + do (js2-record-object-literal + arg (funcall qname-fn subject) (js2-node-abs-pos arg)))))) + +(defun js2-imenu-record-backbone-or-react () + (let* ((node (js2-node-at-point (1- (point)))) + (args (js2-call-node-args node)) + (methods (first args)) + (parent (js2-node-parent node))) + (when (js2-object-node-p methods) + (let ((subject (cond ((js2-var-init-node-p parent) + (js2-var-init-node-target parent)) + ((js2-assign-node-p parent) + (js2-assign-node-left parent))))) + (when subject + (js2-record-object-literal methods + (js2-compute-nested-prop-get subject) + (js2-node-abs-pos methods))))))) + +(defalias 'js2-imenu-record-backbone-extend 'js2-imenu-record-backbone-or-react) + +(defalias 'js2-imenu-record-react-class 'js2-imenu-record-backbone-or-react) + +(defun js2-imenu-record-enyo-kind () + (let* ((node (js2-node-at-point (1- (point)))) + (args (js2-call-node-args node)) + (options (first args))) + (when (js2-object-node-p options) + (let ((name-value + (loop for elem in (js2-object-node-elems options) + thereis + (let ((key (js2-object-prop-node-left elem)) + (value (js2-object-prop-node-right elem))) + (when (and (equal + (cond ((js2-name-node-p key) + (js2-name-node-name key)) + ((js2-string-node-p key) + (js2-string-node-value key))) + "name") + (js2-string-node-p value)) + (js2-string-node-value value)))))) + (when name-value + (js2-record-object-literal options + (if js2-imenu-split-string-identifiers + (split-string name-value "\\.") + (list name-value)) + (js2-node-abs-pos options))))))) + +(defun js2-imenu-record-sencha-class () + (let* ((node (js2-node-at-point (1- (point)))) + (args (js2-call-node-args node)) + (name (first args)) + (methods (second args))) + (when (and (js2-string-node-p name) (js2-object-node-p methods)) + (let ((name-value (js2-string-node-value name))) + (js2-record-object-literal methods + (if js2-imenu-split-string-identifiers + (split-string name-value "\\." t) + (list name-value)) + (js2-node-abs-pos methods)))))) + +(defun js2-imenu-walk-ast () + (js2-visit-ast + js2-mode-ast + (lambda (node end-p) + (unless end-p + (cond + ((and js2-imenu-show-other-functions + (js2-object-prop-node-p node)) + (js2-imenu-record-orphan-prop-node-function node)) + ((js2-assign-node-p node) + (cond + ((and js2-imenu-show-other-functions + (js2-function-node-p + (js2-assign-node-right node))) + (js2-imenu-record-orphan-assign-node-function + (js2-assign-node-left node) + (js2-assign-node-right node))) + ((and js2-imenu-show-module-pattern + (js2-call-node-p + (js2-assign-node-right node))) + (js2-imenu-record-module-pattern + (js2-assign-node-left node) + (js2-assign-node-right node))))) + ((js2-var-init-node-p node) + (cond + ((and js2-imenu-show-other-functions + (js2-function-node-p + (js2-var-init-node-initializer node))) + (js2-imenu-record-orphan-assign-node-function + (js2-var-init-node-target node) + (js2-var-init-node-initializer node))) + ((and js2-imenu-show-module-pattern + (js2-call-node-p + (js2-var-init-node-initializer node))) + (js2-imenu-record-module-pattern + (js2-var-init-node-target node) + (js2-var-init-node-initializer node)))))) + t)))) + +(defun js2-imenu-parent-key-names (node) + "Get the list of parent key names of NODE. + +For example, for code + + {rules: {password: {required: function() {}}}} + +when NODE is the inner `js2-object-prop-mode', +it returns (\"rules\" \"password\")." + (let (rlt (n node)) + (while (setq n (js2-imenu-parent-prop-node n)) + (push (js2-prop-node-name (js2-object-prop-node-left n)) rlt)) + rlt)) + +(defun js2-imenu-parent-prop-node (node) + "When the parent of NODE is `js2-object-node', +and the grandparent is `js2-object-prop-node', +return the grandparent." + ;; Suppose the code is: + ;; {parent-key: {required: function() {}}} + ;; NODE is `required: function() {}'. + (let (p2 p3) + ;; Parent is `{required: function() {}}'. + (setq p2 (js2-node-parent node)) + ;; GP is `parent-key: {required: function() {}}'. + (when (and p2 (js2-object-node-p p2)) + (setq p3 (js2-node-parent p2)) + (if (and p3 (js2-object-prop-node-p p3)) p3)))) + +(defun js2-imenu-record-orphan-prop-node-function (node) + "Record orphan function when it's the value of NODE. +NODE must be `js2-object-prop-node'." + (when (js2-function-node-p (js2-object-prop-node-right node)) + (let ((fn-node (js2-object-prop-node-right node))) + (unless (and js2-imenu-function-map + (gethash fn-node js2-imenu-function-map)) + (let ((key-node (js2-object-prop-node-left node)) + (parent-prop-node (js2-imenu-parent-prop-node node)) + chain) + (setq chain (nconc (js2-imenu-parent-key-names node) + (list (js2-prop-node-name key-node)))) + (push js2-imenu-other-functions-ns chain) + (js2-record-imenu-entry fn-node chain + (js2-node-abs-pos key-node))))))) + +(defun js2-imenu-record-orphan-assign-node-function (target-node fn-node) + "Record orphan function FN-NODE assigned to node TARGET." + (when (or (not js2-imenu-function-map) + (eq 'skip + (gethash fn-node js2-imenu-function-map 'skip))) + (let ((chain (js2-compute-nested-prop-get target-node))) + (when chain + (push js2-imenu-other-functions-ns chain) + (js2-record-imenu-entry fn-node chain (js2-node-abs-pos fn-node)))))) + +(defun js2-imenu-record-module-pattern (target init) + "Recognize and record module pattern use instance. +INIT must be `js2-call-node'." + (let ((callt (js2-call-node-target init))) + ;; Just basic call form: (function() {...})(); + ;; TODO: Handle variations without duplicating `js2-wrapper-function-p'? + (when (and (js2-paren-node-p callt) + (js2-function-node-p (js2-paren-node-expr callt))) + (let* ((fn (js2-paren-node-expr callt)) + (blk (js2-function-node-body fn)) + (ret (car (last (js2-block-node-kids blk))))) + (when (and (js2-return-node-p ret) + (js2-object-node-p (js2-return-node-retval ret))) + ;; TODO: Map function names when revealing module pattern is used. + (let ((retval (js2-return-node-retval ret)) + (target-qname (js2-compute-nested-prop-get target))) + (js2-record-object-literal retval target-qname + (js2-node-abs-pos retval)) + (js2-record-imenu-entry fn target-qname + (js2-node-abs-pos target)))))))) + +;;;###autoload +(define-minor-mode js2-imenu-extras-mode + "Toggle Imenu support for frameworks and structural patterns." + :lighter "" + (if js2-imenu-extras-mode + (js2-imenu-extras-setup) + (js2-imenu-extras-remove))) + +(provide 'js2-imenu-extras)
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/js2-mode-autoloads.el @@ -0,0 +1,68 @@ +;;; js2-mode-autoloads.el --- automatically extracted autoloads +;; +;;; Code: +(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) + +;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (23661 +;;;;;; 47509 788251 222000)) +;;; Generated autoloads from js2-imenu-extras.el + +(autoload 'js2-imenu-extras-setup "js2-imenu-extras" "\ + + +\(fn)" nil nil) + +(autoload 'js2-imenu-extras-mode "js2-imenu-extras" "\ +Toggle Imenu support for frameworks and structural patterns. + +\(fn &optional ARG)" t nil) + +;;;*** + +;;;### (autoloads nil "js2-mode" "js2-mode.el" (23661 47509 764250 +;;;;;; 850000)) +;;; Generated autoloads from js2-mode.el + +(autoload 'js2-highlight-unused-variables-mode "js2-mode" "\ +Toggle highlight of unused variables. + +\(fn &optional ARG)" t nil) + +(autoload 'js2-minor-mode "js2-mode" "\ +Minor mode for running js2 as a background linter. +This allows you to use a different major mode for JavaScript editing, +such as `js-mode', while retaining the asynchronous error/warning +highlighting features of `js2-mode'. + +\(fn &optional ARG)" t nil) + +(autoload 'js2-mode "js2-mode" "\ +Major mode for editing JavaScript code. + +\(fn)" t nil) + +(autoload 'js2-jsx-mode "js2-mode" "\ +Major mode for editing JSX code. + +To customize the indentation for this mode, set the SGML offset +variables (`sgml-basic-offset' et al) locally, like so: + + (defun set-jsx-indentation () + (setq-local sgml-basic-offset js2-basic-offset)) + (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation) + +\(fn)" t nil) + +;;;*** + +;;;### (autoloads nil nil ("js2-mode-pkg.el" "js2-old-indent.el") +;;;;;; (23661 47509 780251 99000)) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; End: +;;; js2-mode-autoloads.el ends here
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/js2-mode-pkg.el @@ -0,0 +1,2 @@ +;; Generated package description from js2-mode.el +(define-package "js2-mode" "20190219" "Improved JavaScript editing mode" '((emacs "24.1") (cl-lib "0.5")) :url "https://github.com/mooz/js2-mode/" :keywords '("languages" "javascript"))
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/js2-mode.el @@ -0,0 +1,12852 @@ +;;; js2-mode.el --- Improved JavaScript editing mode -*- lexical-binding: t -*- + +;; Copyright (C) 2009, 2011-2018 Free Software Foundation, Inc. + +;; Author: Steve Yegge <steve.yegge@gmail.com> +;; mooz <stillpedant@gmail.com> +;; Dmitry Gutov <dgutov@yandex.ru> +;; URL: https://github.com/mooz/js2-mode/ +;; http://code.google.com/p/js2-mode/ +;; Version: 20190219 +;; Keywords: languages, javascript +;; Package-Requires: ((emacs "24.1") (cl-lib "0.5")) + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Commentary: + +;; This JavaScript editing mode supports: + +;; - strict recognition of the Ecma-262 language standard +;; - support for most Rhino and SpiderMonkey extensions from 1.5 and up +;; - parsing support for ECMAScript for XML (E4X, ECMA-357) +;; - accurate syntax highlighting using a recursive-descent parser +;; - on-the-fly reporting of syntax errors and strict-mode warnings +;; - undeclared-variable warnings using a configurable externs framework +;; - "bouncing" line indentation to choose among alternate indentation points +;; - smart line-wrapping within comments and strings +;; - code folding: +;; - show some or all function bodies as {...} +;; - show some or all block comments as /*...*/ +;; - context-sensitive menu bar and popup menus +;; - code browsing using the `imenu' package +;; - many customization options + +;; Installation: +;; +;; To install it as your major mode for JavaScript editing: + +;; (add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode)) + +;; Alternatively, to install it as a minor mode just for JavaScript linting, +;; you must add it to the appropriate major-mode hook. Normally this would be: + +;; (add-hook 'js-mode-hook 'js2-minor-mode) + +;; You may also want to hook it in for shell scripts running via node.js: + +;; (add-to-list 'interpreter-mode-alist '("node" . js2-mode)) + +;; Support for JSX is available via the derived mode `js2-jsx-mode'. If you +;; also want JSX support, use that mode instead: + +;; (add-to-list 'auto-mode-alist '("\\.jsx?\\'" . js2-jsx-mode)) +;; (add-to-list 'interpreter-mode-alist '("node" . js2-jsx-mode)) + +;; To customize how it works: +;; M-x customize-group RET js2-mode RET + +;; Notes: + +;; This mode includes a port of Mozilla Rhino's scanner, parser and +;; symbol table. Ideally it should stay in sync with Rhino, keeping +;; `js2-mode' current as the EcmaScript language standard evolves. + +;; Unlike cc-engine based language modes, js2-mode's line-indentation is not +;; customizable. It is a surprising amount of work to support customizable +;; indentation. The current compromise is that the tab key lets you cycle among +;; various likely indentation points, similar to the behavior of python-mode. + +;; This mode does not yet work with "multi-mode" modes such as `mmm-mode' +;; and `mumamo', although it could be made to do so with some effort. +;; This means that `js2-mode' is currently only useful for editing JavaScript +;; files, and not for editing JavaScript within <script> tags or templates. + +;; The project page on GitHub is used for development and issue tracking. +;; The original homepage at Google Code has outdated information and is mostly +;; unmaintained. + +;;; Code: + +(require 'cl-lib) +(require 'imenu) +(require 'js) +(require 'etags) + +(eval-and-compile + (if (version< emacs-version "25.0") + (require 'js2-old-indent) + (defvaralias 'js2-basic-offset 'js-indent-level nil) + (defalias 'js2-proper-indentation 'js--proper-indentation) + (defalias 'js2-jsx-indent-line 'js-jsx-indent-line) + (defalias 'js2-indent-line 'js-indent-line) + (defalias 'js2-re-search-forward 'js--re-search-forward))) + +;;; Externs (variables presumed to be defined by the host system) + +(defvar js2-ecma-262-externs + (mapcar 'symbol-name + '(Array Boolean Date Error EvalError Function Infinity JSON + Math NaN Number Object RangeError ReferenceError RegExp + String SyntaxError TypeError URIError + decodeURI decodeURIComponent encodeURI + encodeURIComponent escape eval isFinite isNaN + parseFloat parseInt undefined unescape)) +"Ecma-262 externs. Never highlighted as undeclared variables.") + +(defvar js2-browser-externs + (mapcar 'symbol-name + '(;; DOM level 1 + Attr CDATASection CharacterData Comment DOMException + DOMImplementation Document DocumentFragment + DocumentType Element Entity EntityReference + ExceptionCode NamedNodeMap Node NodeList Notation + ProcessingInstruction Text + + ;; DOM level 2 + HTMLAnchorElement HTMLAppletElement HTMLAreaElement + HTMLBRElement HTMLBaseElement HTMLBaseFontElement + HTMLBodyElement HTMLButtonElement HTMLCollection + HTMLDListElement HTMLDirectoryElement HTMLDivElement + HTMLDocument HTMLElement HTMLFieldSetElement + HTMLFontElement HTMLFormElement HTMLFrameElement + HTMLFrameSetElement HTMLHRElement HTMLHeadElement + HTMLHeadingElement HTMLHtmlElement HTMLIFrameElement + HTMLImageElement HTMLInputElement HTMLIsIndexElement + HTMLLIElement HTMLLabelElement HTMLLegendElement + HTMLLinkElement HTMLMapElement HTMLMenuElement + HTMLMetaElement HTMLModElement HTMLOListElement + HTMLObjectElement HTMLOptGroupElement + HTMLOptionElement HTMLOptionsCollection + HTMLParagraphElement HTMLParamElement HTMLPreElement + HTMLQuoteElement HTMLScriptElement HTMLSelectElement + HTMLStyleElement HTMLTableCaptionElement + HTMLTableCellElement HTMLTableColElement + HTMLTableElement HTMLTableRowElement + HTMLTableSectionElement HTMLTextAreaElement + HTMLTitleElement HTMLUListElement + + ;; DOM level 3 + DOMConfiguration DOMError DOMException + DOMImplementationList DOMImplementationSource + DOMLocator DOMStringList NameList TypeInfo + UserDataHandler + + ;; Window + window alert confirm document java navigator prompt screen + self top requestAnimationFrame cancelAnimationFrame + + ;; W3C CSS + CSSCharsetRule CSSFontFace CSSFontFaceRule + CSSImportRule CSSMediaRule CSSPageRule + CSSPrimitiveValue CSSProperties CSSRule CSSRuleList + CSSStyleDeclaration CSSStyleRule CSSStyleSheet + CSSValue CSSValueList Counter DOMImplementationCSS + DocumentCSS DocumentStyle ElementCSSInlineStyle + LinkStyle MediaList RGBColor Rect StyleSheet + StyleSheetList ViewCSS + + ;; W3C Event + EventListener EventTarget Event DocumentEvent UIEvent + MouseEvent MutationEvent KeyboardEvent + + ;; W3C Range + DocumentRange Range RangeException + + ;; W3C XML + XPathResult XMLHttpRequest + + ;; console object. Provided by at least Chrome and Firefox. + console)) + "Browser externs. +You can cause these to be included or excluded with the custom +variable `js2-include-browser-externs'.") + +(defvar js2-rhino-externs + (mapcar 'symbol-name + '(Packages importClass importPackage com org java + ;; Global object (shell) externs. + defineClass deserialize doctest gc help load + loadClass print quit readFile readUrl runCommand seal + serialize spawn sync toint32 version)) + "Mozilla Rhino externs. +Set `js2-include-rhino-externs' to t to include them.") + +(defvar js2-node-externs + (mapcar 'symbol-name + '(__dirname __filename Buffer clearInterval clearTimeout require + console exports global module process setInterval setTimeout + querystring setImmediate clearImmediate)) + "Node.js externs. +Set `js2-include-node-externs' to t to include them.") + +(defvar js2-typed-array-externs + (mapcar 'symbol-name + '(ArrayBuffer Uint8ClampedArray DataView + Int8Array Uint8Array Int16Array Uint16Array Int32Array Uint32Array + Float32Array Float64Array)) + "Khronos typed array externs. Available in most modern browsers and +in node.js >= 0.6. If `js2-include-node-externs' or `js2-include-browser-externs' +are enabled, these will also be included.") + +(defvar js2-harmony-externs + (mapcar 'symbol-name + '(Map Promise Proxy Reflect Set Symbol WeakMap WeakSet)) + "ES6 externs. If `js2-include-browser-externs' is enabled and +`js2-language-version' is sufficiently high, these will be included.") + +;;; Variables + +(defcustom js2-ignored-warnings nil + "A list of warning message types that will not be reported. + +Possible values are the keys of `js2-message-table'." + :group 'js2-mode + :type '(repeat string)) + +(defcustom js2-highlight-level 2 + "Amount of syntax highlighting to perform. +0 or a negative value means none. +1 adds basic syntax highlighting. +2 adds highlighting of some Ecma built-in properties. +3 adds highlighting of many Ecma built-in functions." + :group 'js2-mode + :type '(choice (const :tag "None" 0) + (const :tag "Basic" 1) + (const :tag "Include Properties" 2) + (const :tag "Include Functions" 3))) + +(defvar js2-mode-dev-mode-p nil + "Non-nil if running in development mode. Normally nil.") + +(defgroup js2-mode nil + "An improved JavaScript mode." + :group 'languages) + +(defcustom js2-idle-timer-delay 0.2 + "Delay in secs before re-parsing after user makes changes. +Multiplied by `js2-dynamic-idle-timer-adjust', which see." + :type 'number + :group 'js2-mode) +(make-variable-buffer-local 'js2-idle-timer-delay) + +(defcustom js2-dynamic-idle-timer-adjust 0 + "Positive to adjust `js2-idle-timer-delay' based on file size. +The idea is that for short files, parsing is faster so we can be +more responsive to user edits without interfering with editing. +The buffer length in characters (typically bytes) is divided by +this value and used to multiply `js2-idle-timer-delay' for the +buffer. For example, a 21k file and 10k adjust yields 21k/10k +== 2, so js2-idle-timer-delay is multiplied by 2. +If `js2-dynamic-idle-timer-adjust' is 0 or negative, +`js2-idle-timer-delay' is not dependent on the file size." + :type 'number + :group 'js2-mode) + +(defcustom js2-concat-multiline-strings t + "When non-nil, `js2-line-break' in mid-string will make it a +string concatenation. When `eol', the `+' will be inserted at the +end of the line, otherwise, at the beginning of the next line." + :type '(choice (const t) (const eol) (const nil)) + :group 'js2-mode) + +(defcustom js2-mode-show-parse-errors t + "True to highlight parse errors." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-mode-assume-strict nil + "Non-nil to start files in strict mode automatically." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-mode-show-strict-warnings t + "Non-nil to emit Ecma strict-mode warnings. +Some of the warnings can be individually disabled by other flags, +even if this flag is non-nil." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-strict-trailing-comma-warning nil + "Non-nil to warn about trailing commas in array literals. +Ecma-262-5.1 allows them, but older versions of IE raise an error." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-strict-missing-semi-warning t + "Non-nil to warn about semicolon auto-insertion after statement. +Technically this is legal per Ecma-262, but some style guides disallow +depending on it." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-missing-semi-one-line-override nil + "Non-nil to permit missing semicolons in one-line functions. +In one-liner functions such as `function identity(x) {return x}' +people often omit the semicolon for a cleaner look. If you are +such a person, you can suppress the missing-semicolon warning +by setting this variable to t." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-strict-inconsistent-return-warning t + "Non-nil to warn about mixing returns with value-returns. +It's perfectly legal to have a `return' and a `return foo' in the +same function, but it's often an indicator of a bug, and it also +interferes with type inference (in systems that support it.)" + :type 'boolean + :group 'js2-mode) + +(defcustom js2-strict-cond-assign-warning t + "Non-nil to warn about usage like `if (a = b)'. +This often should have been `==' instead of `='. If the warning +is enabled, you can suppress it on a per-expression basis by +parenthesizing the expression, e.g., `if ((a = b)) ...'." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-strict-var-redeclaration-warning t + "Non-nil to warn about redeclaring variables in a script or function." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-strict-var-hides-function-arg-warning t + "Non-nil to warn about a var decl hiding a function argument." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-skip-preprocessor-directives nil + "Non-nil to treat lines beginning with # as comments. +Useful for viewing Mozilla JavaScript source code." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-language-version 200 + "Configures what JavaScript language version to recognize. +Currently versions 150, 160, 170, 180 and 200 are supported, +corresponding to JavaScript 1.5, 1.6, 1.7, 1.8 and 2.0 (Harmony), +respectively. In a nutshell, 1.6 adds E4X support, 1.7 adds let, +yield, and Array comprehensions, and 1.8 adds function closures." + :type 'integer + :group 'js2-mode) + +(defcustom js2-instanceof-has-side-effects nil + "If non-nil, treats the instanceof operator as having side effects. +This is useful for xulrunner apps." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-getprop-has-side-effects nil + "If non-nil, treats the getprop operator as having side effects. +This is useful for testing libraries with nontrivial getters and for +compilers that use empty getprops to declare interface properties." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-move-point-on-right-click t + "Non-nil to move insertion point when you right-click. +This makes right-click context menu behavior a bit more intuitive, +since menu operations generally apply to the point. The exception +is if there is a region selection, in which case the point does -not- +move, so cut/copy/paste can work properly. + +Note that IntelliJ moves the point, and Eclipse leaves it alone, +so this behavior is customizable." + :group 'js2-mode + :type 'boolean) + +(defcustom js2-allow-rhino-new-expr-initializer t + "Non-nil to support a Rhino's experimental syntactic construct. + +Rhino supports the ability to follow a `new' expression with an object +literal, which is used to set additional properties on the new object +after calling its constructor. Syntax: + + new <expr> [ ( arglist ) ] [initializer] + +Hence, this expression: + + new Object {a: 1, b: 2} + +results in an Object with properties a=1 and b=2. This syntax is +apparently not configurable in Rhino - it's currently always enabled, +as of Rhino version 1.7R2." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-allow-member-expr-as-function-name nil + "Non-nil to support experimental Rhino syntax for function names. + +Rhino supports an experimental syntax configured via the Rhino Context +setting `allowMemberExprAsFunctionName'. The experimental syntax is: + + function <member-expr> ( [ arg-list ] ) { <body> } + +Where member-expr is a non-parenthesized `member expression', which +is anything at the grammar level of a new-expression or lower, meaning +any expression that does not involve infix or unary operators. + +When <member-expr> is not a simple identifier, then it is syntactic +sugar for assigning the anonymous function to the <member-expr>. Hence, +this code: + + function a.b().c[2] (x, y) { ... } + +is rewritten as: + + a.b().c[2] = function(x, y) {...} + +which doesn't seem particularly useful, but Rhino permits it." + :type 'boolean + :group 'js2-mode) + +;; scanner variables + +(defmacro js2-deflocal (name value &optional comment) + "Define a buffer-local variable NAME with VALUE and COMMENT." + (declare (debug defvar) (doc-string 3)) + `(progn + (defvar ,name ,value ,comment) + (make-variable-buffer-local ',name))) + +(defvar js2-EOF_CHAR -1 + "Represents end of stream. Distinct from js2-EOF token type.") + +;; I originally used symbols to represent tokens, but Rhino uses +;; ints and then sets various flag bits in them, so ints it is. +;; The upshot is that we need a `js2-' prefix in front of each name. +(defvar js2-ERROR -1) +(defvar js2-EOF 0) +(defvar js2-EOL 1) +(defvar js2-ENTERWITH 2) ; begin interpreter bytecodes +(defvar js2-LEAVEWITH 3) +(defvar js2-RETURN 4) +(defvar js2-GOTO 5) +(defvar js2-IFEQ 6) +(defvar js2-IFNE 7) +(defvar js2-SETNAME 8) +(defvar js2-BITOR 9) +(defvar js2-BITXOR 10) +(defvar js2-BITAND 11) +(defvar js2-EQ 12) +(defvar js2-NE 13) +(defvar js2-LT 14) +(defvar js2-LE 15) +(defvar js2-GT 16) +(defvar js2-GE 17) +(defvar js2-LSH 18) +(defvar js2-RSH 19) +(defvar js2-URSH 20) +(defvar js2-ADD 21) ; infix plus +(defvar js2-SUB 22) ; infix minus +(defvar js2-MUL 23) +(defvar js2-DIV 24) +(defvar js2-MOD 25) +(defvar js2-NOT 26) +(defvar js2-BITNOT 27) +(defvar js2-POS 28) ; unary plus +(defvar js2-NEG 29) ; unary minus +(defvar js2-NEW 30) +(defvar js2-DELPROP 31) +(defvar js2-TYPEOF 32) +(defvar js2-GETPROP 33) +(defvar js2-GETPROPNOWARN 34) +(defvar js2-SETPROP 35) +(defvar js2-GETELEM 36) +(defvar js2-SETELEM 37) +(defvar js2-CALL 38) +(defvar js2-NAME 39) ; an identifier +(defvar js2-NUMBER 40) +(defvar js2-STRING 41) +(defvar js2-NULL 42) +(defvar js2-THIS 43) +(defvar js2-FALSE 44) +(defvar js2-TRUE 45) +(defvar js2-SHEQ 46) ; shallow equality (===) +(defvar js2-SHNE 47) ; shallow inequality (!==) +(defvar js2-REGEXP 48) +(defvar js2-BINDNAME 49) +(defvar js2-THROW 50) +(defvar js2-RETHROW 51) ; rethrow caught exception: catch (e if ) uses it +(defvar js2-IN 52) +(defvar js2-INSTANCEOF 53) +(defvar js2-LOCAL_LOAD 54) +(defvar js2-GETVAR 55) +(defvar js2-SETVAR 56) +(defvar js2-CATCH_SCOPE 57) +(defvar js2-ENUM_INIT_KEYS 58) ; FIXME: what are these? +(defvar js2-ENUM_INIT_VALUES 59) +(defvar js2-ENUM_INIT_ARRAY 60) +(defvar js2-ENUM_NEXT 61) +(defvar js2-ENUM_ID 62) +(defvar js2-THISFN 63) +(defvar js2-RETURN_RESULT 64) ; to return previously stored return result +(defvar js2-ARRAYLIT 65) ; array literal +(defvar js2-OBJECTLIT 66) ; object literal +(defvar js2-GET_REF 67) ; *reference +(defvar js2-SET_REF 68) ; *reference = something +(defvar js2-DEL_REF 69) ; delete reference +(defvar js2-REF_CALL 70) ; f(args) = something or f(args)++ +(defvar js2-REF_SPECIAL 71) ; reference for special properties like __proto +(defvar js2-YIELD 72) ; JS 1.7 yield pseudo keyword + +;; XML support +(defvar js2-DEFAULTNAMESPACE 73) +(defvar js2-ESCXMLATTR 74) +(defvar js2-ESCXMLTEXT 75) +(defvar js2-REF_MEMBER 76) ; Reference for x.@y, x..y etc. +(defvar js2-REF_NS_MEMBER 77) ; Reference for x.ns::y, x..ns::y etc. +(defvar js2-REF_NAME 78) ; Reference for @y, @[y] etc. +(defvar js2-REF_NS_NAME 79) ; Reference for ns::y, @ns::y@[y] etc. + +(defvar js2-first-bytecode js2-ENTERWITH) +(defvar js2-last-bytecode js2-REF_NS_NAME) + +(defvar js2-TRY 80) +(defvar js2-SEMI 81) ; semicolon +(defvar js2-LB 82) ; left and right brackets +(defvar js2-RB 83) +(defvar js2-LC 84) ; left and right curly-braces +(defvar js2-RC 85) +(defvar js2-LP 86) ; left and right parens +(defvar js2-RP 87) +(defvar js2-COMMA 88) ; comma operator + +(defvar js2-ASSIGN 89) ; simple assignment (=) +(defvar js2-ASSIGN_BITOR 90) ; |= +(defvar js2-ASSIGN_BITXOR 91) ; ^= +(defvar js2-ASSIGN_BITAND 92) ; &= +(defvar js2-ASSIGN_LSH 93) ; <<= +(defvar js2-ASSIGN_RSH 94) ; >>= +(defvar js2-ASSIGN_URSH 95) ; >>>= +(defvar js2-ASSIGN_ADD 96) ; += +(defvar js2-ASSIGN_SUB 97) ; -= +(defvar js2-ASSIGN_MUL 98) ; *= +(defvar js2-ASSIGN_DIV 99) ; /= +(defvar js2-ASSIGN_MOD 100) ; %= +(defvar js2-ASSIGN_EXPON 101) + +(defvar js2-first-assign js2-ASSIGN) +(defvar js2-last-assign js2-ASSIGN_EXPON) + +(defvar js2-COLON 102) +(defvar js2-OR 103) ; logical or (||) +(defvar js2-AND 104) ; logical and (&&) +(defvar js2-INC 105) ; increment/decrement (++ --) +(defvar js2-DEC 106) +(defvar js2-DOT 107) ; member operator (.) +(defvar js2-FUNCTION 108) ; function keyword +(defvar js2-EXPORT 109) ; export keyword +(defvar js2-IMPORT 110) ; import keyword +(defvar js2-IF 111) ; if keyword +(defvar js2-ELSE 112) ; else keyword +(defvar js2-SWITCH 113) ; switch keyword +(defvar js2-CASE 114) ; case keyword +(defvar js2-DEFAULT 115) ; default keyword +(defvar js2-WHILE 116) ; while keyword +(defvar js2-DO 117) ; do keyword +(defvar js2-FOR 118) ; for keyword +(defvar js2-BREAK 119) ; break keyword +(defvar js2-CONTINUE 120) ; continue keyword +(defvar js2-VAR 121) ; var keyword +(defvar js2-WITH 122) ; with keyword +(defvar js2-CATCH 123) ; catch keyword +(defvar js2-FINALLY 124) ; finally keyword +(defvar js2-VOID 125) ; void keyword +(defvar js2-RESERVED 126) ; reserved keywords + +(defvar js2-EMPTY 127) + +;; Types used for the parse tree - never returned by scanner. + +(defvar js2-BLOCK 128) ; statement block +(defvar js2-LABEL 129) ; label +(defvar js2-TARGET 130) +(defvar js2-LOOP 131) +(defvar js2-EXPR_VOID 132) ; expression statement in functions +(defvar js2-EXPR_RESULT 133) ; expression statement in scripts +(defvar js2-JSR 134) +(defvar js2-SCRIPT 135) ; top-level node for entire script +(defvar js2-TYPEOFNAME 136) ; for typeof(simple-name) +(defvar js2-USE_STACK 137) +(defvar js2-SETPROP_OP 138) ; x.y op= something +(defvar js2-SETELEM_OP 139) ; x[y] op= something +(defvar js2-LOCAL_BLOCK 140) +(defvar js2-SET_REF_OP 141) ; *reference op= something + +;; For XML support: +(defvar js2-DOTDOT 142) ; member operator (..) +(defvar js2-COLONCOLON 143) ; namespace::name +(defvar js2-XML 144) ; XML type +(defvar js2-DOTQUERY 145) ; .() -- e.g., x.emps.emp.(name == "terry") +(defvar js2-XMLATTR 146) ; @ +(defvar js2-XMLEND 147) + +;; Optimizer-only tokens +(defvar js2-TO_OBJECT 148) +(defvar js2-TO_DOUBLE 149) + +(defvar js2-GET 150) ; JS 1.5 get pseudo keyword +(defvar js2-SET 151) ; JS 1.5 set pseudo keyword +(defvar js2-LET 152) ; JS 1.7 let pseudo keyword +(defvar js2-CONST 153) +(defvar js2-SETCONST 154) +(defvar js2-SETCONSTVAR 155) +(defvar js2-ARRAYCOMP 156) +(defvar js2-LETEXPR 157) +(defvar js2-WITHEXPR 158) +(defvar js2-DEBUGGER 159) + +(defvar js2-COMMENT 160) +(defvar js2-TRIPLEDOT 161) ; for rest parameter +(defvar js2-ARROW 162) ; function arrow (=>) +(defvar js2-CLASS 163) +(defvar js2-EXTENDS 164) +(defvar js2-SUPER 165) +(defvar js2-TEMPLATE_HEAD 166) ; part of template literal before substitution +(defvar js2-NO_SUBS_TEMPLATE 167) ; template literal without substitutions +(defvar js2-TAGGED_TEMPLATE 168) ; tagged template literal + +(defvar js2-AWAIT 169) ; await (pseudo keyword) + +(defvar js2-HOOK 170) ; conditional (?:) +(defvar js2-EXPON 171) + +(defconst js2-num-tokens (1+ js2-EXPON)) + +(defconst js2-debug-print-trees nil) + +;; Rhino accepts any string or stream as input. Emacs character +;; processing works best in buffers, so we'll assume the input is a +;; buffer. JavaScript strings can be copied into temp buffers before +;; scanning them. + +;; Buffer-local variables yield much cleaner code than using `defstruct'. +;; They're the Emacs equivalent of instance variables, more or less. + +(js2-deflocal js2-ts-dirty-line nil + "Token stream buffer-local variable. +Indicates stuff other than whitespace since start of line.") + +(js2-deflocal js2-ts-hit-eof nil + "Token stream buffer-local variable.") + +;; FIXME: Unused. +(js2-deflocal js2-ts-line-start 0 + "Token stream buffer-local variable.") + +(js2-deflocal js2-ts-lineno 1 + "Token stream buffer-local variable.") + +;; FIXME: Unused. +(js2-deflocal js2-ts-line-end-char -1 + "Token stream buffer-local variable.") + +(js2-deflocal js2-ts-cursor 1 ; emacs buffers are 1-indexed + "Token stream buffer-local variable. +Current scan position.") + +;; FIXME: Unused. +(js2-deflocal js2-ts-is-xml-attribute nil + "Token stream buffer-local variable.") + +(js2-deflocal js2-ts-xml-is-tag-content nil + "Token stream buffer-local variable.") + +(js2-deflocal js2-ts-xml-open-tags-count 0 + "Token stream buffer-local variable.") + +(js2-deflocal js2-ts-string-buffer nil + "Token stream buffer-local variable. +List of chars built up while scanning various tokens.") + +(cl-defstruct (js2-token + (:constructor make-js2-token (beg))) + "Value returned from the token stream." + (type js2-EOF) + (beg 1) + (end -1) + (string "") + number + number-base + number-legacy-octal-p + regexp-flags + comment-type + follows-eol-p) + +;; Have to call `js2-init-scanner' to initialize the values. +(js2-deflocal js2-ti-tokens nil) +(js2-deflocal js2-ti-tokens-cursor nil) +(js2-deflocal js2-ti-lookahead nil) + +(cl-defstruct (js2-ts-state + (:constructor make-js2-ts-state (&key (lineno js2-ts-lineno) + (cursor js2-ts-cursor) + (tokens (copy-sequence js2-ti-tokens)) + (tokens-cursor js2-ti-tokens-cursor) + (lookahead js2-ti-lookahead)))) + lineno + cursor + tokens + tokens-cursor + lookahead) + +;;; Parser variables + +(js2-deflocal js2-parsed-errors nil + "List of errors produced during scanning/parsing.") + +(js2-deflocal js2-parsed-warnings nil + "List of warnings produced during scanning/parsing.") + +(js2-deflocal js2-recover-from-parse-errors t + "Non-nil to continue parsing after a syntax error. + +In recovery mode, the AST will be built in full, and any error +nodes will be flagged with appropriate error information. If +this flag is nil, a syntax error will result in an error being +signaled. + +The variable is automatically buffer-local, because different +modes that use the parser will need different settings.") + +(js2-deflocal js2-parse-hook nil + "List of callbacks for receiving parsing progress.") + +(defvar js2-parse-finished-hook nil + "List of callbacks to notify when parsing finishes. +Not called if parsing was interrupted.") + +(js2-deflocal js2-is-eval-code nil + "True if we're evaluating code in a string. +If non-nil, the tokenizer will record the token text, and the AST nodes +will record their source text. Off by default for IDE modes, since the +text is available in the buffer.") + +(defvar js2-parse-ide-mode t + "Non-nil if the parser is being used for `js2-mode'. +If non-nil, the parser will set text properties for fontification +and the syntax table. The value should be nil when using the +parser as a frontend to an interpreter or byte compiler.") + +;;; Parser instance variables (buffer-local vars for js2-parse) + +(defconst js2-ti-after-eol (lsh 1 16) + "Flag: first token of the source line.") + +;; Inline Rhino's CompilerEnvirons vars as buffer-locals. + +(js2-deflocal js2-compiler-generate-debug-info t) +(js2-deflocal js2-compiler-use-dynamic-scope nil) +(js2-deflocal js2-compiler-reserved-keywords-as-identifier nil) +(js2-deflocal js2-compiler-xml-available t) +(js2-deflocal js2-compiler-optimization-level 0) +(js2-deflocal js2-compiler-generating-source t) +(js2-deflocal js2-compiler-strict-mode nil) +(js2-deflocal js2-compiler-report-warning-as-error nil) +(js2-deflocal js2-compiler-generate-observer-count nil) +(js2-deflocal js2-compiler-activation-names nil) + +;; SKIP: sourceURI + +;; There's a compileFunction method in Context.java - may need it. +(js2-deflocal js2-called-by-compile-function nil + "True if `js2-parse' was called by `js2-compile-function'. +Will only be used when we finish implementing the interpreter.") + +;; SKIP: ts (we just call `js2-init-scanner' and use its vars) + +;; SKIP: node factory - we're going to just call functions directly, +;; and eventually go to a unified AST format. + +(js2-deflocal js2-nesting-of-function 0) + +(js2-deflocal js2-recorded-identifiers nil + "Tracks identifiers found during parsing.") + +(js2-deflocal js2-is-in-destructuring nil + "True while parsing destructuring expression.") + +(js2-deflocal js2-in-use-strict-directive nil + "True while inside a script or function under strict mode.") + +(defcustom js2-global-externs nil + "A list of any extern names you'd like to consider always declared. +This list is global and is used by all `js2-mode' files. +You can create buffer-local externs list using `js2-additional-externs'." + :type 'list + :group 'js2-mode) + +(defcustom js2-include-browser-externs t + "Non-nil to include browser externs in the master externs list. +If you work on JavaScript files that are not intended for browsers, +such as Mozilla Rhino server-side JavaScript, set this to nil. +See `js2-additional-externs' for more information about externs." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-include-rhino-externs nil + "Non-nil to include Mozilla Rhino externs in the master externs list. +See `js2-additional-externs' for more information about externs." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-include-node-externs nil + "Non-nil to include Node.js externs in the master externs list. +See `js2-additional-externs' for more information about externs." + :type 'boolean + :group 'js2-mode) + +(js2-deflocal js2-additional-externs nil + "A buffer-local list of additional external declarations. +It is used to decide whether variables are considered undeclared +for purposes of highlighting. See `js2-highlight-undeclared-vars'. + +Each entry is a Lisp string. The string should be the fully qualified +name of an external entity. All externs should be added to this list, +so that as js2-mode's processing improves it can take advantage of them. + +You may want to declare your externs in three ways. +First, you can add externs that are valid for all your JavaScript files. +You should probably do this by adding them to `js2-global-externs', which +is a global list used for all js2-mode files. + +Next, you can add a function to `js2-init-hook' that adds additional +externs appropriate for the specific file, perhaps based on its path. +These should go in `js2-additional-externs', which is buffer-local. + +Third, you can use JSLint's global declaration, as long as +`js2-include-jslint-globals' is non-nil, which see. + +Finally, you can add a function to `js2-post-parse-callbacks', +which is called after parsing completes, and `js2-mode-ast' is bound to +the root of the parse tree. At this stage you can set up an AST +node visitor using `js2-visit-ast' and examine the parse tree +for specific import patterns that may imply the existence of +other externs, possibly tied to your build system. These should also +be added to `js2-additional-externs'. + +Your post-parse callback may of course also use the simpler and +faster (but perhaps less robust) approach of simply scanning the +buffer text for your imports, using regular expressions.") + +(put 'js2-additional-externs 'safe-local-variable + (lambda (val) (cl-every #'stringp val))) + +;; SKIP: decompiler +;; SKIP: encoded-source + +;;; The following variables are per-function and should be saved/restored +;;; during function parsing... + +(js2-deflocal js2-current-script-or-fn nil) +(js2-deflocal js2-current-scope nil) +(js2-deflocal js2-nesting-of-with 0) +(js2-deflocal js2-label-set nil + "An alist mapping label names to nodes.") + +(js2-deflocal js2-loop-set nil) +(js2-deflocal js2-loop-and-switch-set nil) +(js2-deflocal js2-has-return-value nil) +(js2-deflocal js2-end-flags 0) + +;;; ...end of per function variables + +;; These flags enumerate the possible ways a statement/function can +;; terminate. These flags are used by endCheck() and by the Parser to +;; detect inconsistent return usage. +;; +;; END_UNREACHED is reserved for code paths that are assumed to always be +;; able to execute (example: throw, continue) +;; +;; END_DROPS_OFF indicates if the statement can transfer control to the +;; next one. Statement such as return dont. A compound statement may have +;; some branch that drops off control to the next statement. +;; +;; END_RETURNS indicates that the statement can return (without arguments) +;; END_RETURNS_VALUE indicates that the statement can return a value. +;; +;; A compound statement such as +;; if (condition) { +;; return value; +;; } +;; Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck() + +(defconst js2-end-unreached #x0) +(defconst js2-end-drops-off #x1) +(defconst js2-end-returns #x2) +(defconst js2-end-returns-value #x4) + +;; Rhino awkwardly passes a statementLabel parameter to the +;; statementHelper() function, the main statement parser, which +;; is then used by quite a few of the sub-parsers. We just make +;; it a buffer-local variable and make sure it's cleaned up properly. +(js2-deflocal js2-labeled-stmt nil) ; type `js2-labeled-stmt-node' + +;; Similarly, Rhino passes an inForInit boolean through about half +;; the expression parsers. We use a dynamically-scoped variable, +;; which makes it easier to funcall the parsers individually without +;; worrying about whether they take the parameter or not. +(js2-deflocal js2-in-for-init nil) +(js2-deflocal js2-temp-name-counter 0) +(js2-deflocal js2-parse-stmt-count 0) + +(defsubst js2-get-next-temp-name () + (format "$%d" (cl-incf js2-temp-name-counter))) + +(defvar js2-parse-interruptable-p t + "Set this to nil to force parse to continue until finished. +This will mostly be useful for interpreters.") + +(defvar js2-statements-per-pause 50 + "Pause after this many statements to check for user input. +If user input is pending, stop the parse and discard the tree. +This makes for a smoother user experience for large files. +You may have to wait a second or two before the highlighting +and error-reporting appear, but you can always type ahead if +you wish. This appears to be more or less how Eclipse, IntelliJ +and other editors work.") + +(js2-deflocal js2-record-comments t + "Instructs the scanner to record comments in `js2-scanned-comments'.") + +(js2-deflocal js2-scanned-comments nil + "List of all comments from the current parse.") + +(defcustom js2-mode-indent-inhibit-undo nil + "Non-nil to disable collection of Undo information when indenting lines. +Some users have requested this behavior. It's nil by default because +other Emacs modes don't work this way." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-mode-indent-ignore-first-tab nil + "If non-nil, ignore first TAB keypress if we look indented properly. +It's fairly common for users to navigate to an already-indented line +and press TAB for reassurance that it's been indented. For this class +of users, we want the first TAB press on a line to be ignored if the +line is already indented to one of the precomputed alternatives. + +This behavior is only partly implemented. If you TAB-indent a line, +navigate to another line, and then navigate back, it fails to clear +the last-indented variable, so it thinks you've already hit TAB once, +and performs the indent. A full solution would involve getting on the +point-motion hooks for the entire buffer. If we come across another +use cases that requires watching point motion, I'll consider doing it. + +If you set this variable to nil, then the TAB key will always change +the indentation of the current line, if more than one alternative +indentation spot exists." + :type 'boolean + :group 'js2-mode) + +(defvar js2-indent-hook nil + "A hook for user-defined indentation rules. + +Functions on this hook should expect two arguments: (LIST INDEX) +The LIST argument is the list of computed indentation points for +the current line. INDEX is the list index of the indentation point +that `js2-bounce-indent' plans to use. If INDEX is nil, then the +indent function is not going to change the current line indentation. + +If a hook function on this list returns a non-nil value, then +`js2-bounce-indent' assumes the hook function has performed its own +indentation, and will do nothing. If all hook functions on the list +return nil, then `js2-bounce-indent' will use its computed indentation +and reindent the line. + +When hook functions on this hook list are called, the variable +`js2-mode-ast' may or may not be set, depending on whether the +parse tree is available. If the variable is nil, you can pass a +callback to `js2-mode-wait-for-parse', and your callback will be +called after the new parse tree is built. This can take some time +in large files.") + +(defface js2-warning + `((((class color) (background light)) + (:underline "orange")) + (((class color) (background dark)) + (:underline "orange")) + (t (:underline t))) + "Face for JavaScript warnings." + :group 'js2-mode) + +(defface js2-error + `((((class color) (background light)) + (:foreground "red")) + (((class color) (background dark)) + (:foreground "red")) + (t (:foreground "red"))) + "Face for JavaScript errors." + :group 'js2-mode) + +(defface js2-jsdoc-tag + '((t :foreground "SlateGray")) + "Face used to highlight @whatever tags in jsdoc comments." + :group 'js2-mode) + +(defface js2-jsdoc-type + '((t :foreground "SteelBlue")) + "Face used to highlight {FooBar} types in jsdoc comments." + :group 'js2-mode) + +(defface js2-jsdoc-value + '((t :foreground "PeachPuff3")) + "Face used to highlight tag values in jsdoc comments." + :group 'js2-mode) + +(defface js2-function-param + '((t :foreground "SeaGreen")) + "Face used to highlight function parameters in javascript." + :group 'js2-mode) + +(defface js2-function-call + '((t :inherit default)) + "Face used to highlight function name in calls." + :group 'js2-mode) + +(defface js2-object-property + '((t :inherit default)) + "Face used to highlight named property in object literal." + :group 'js2-mode) + +(defface js2-object-property-access + '((t :inherit js2-object-property)) + "Face used to highlight property access with dot on an object." + :group 'js2-mode) + +(defface js2-instance-member + '((t :foreground "DarkOrchid")) + "Face used to highlight instance variables in javascript. +Not currently used." + :group 'js2-mode) + +(defface js2-private-member + '((t :foreground "PeachPuff3")) + "Face used to highlight calls to private methods in javascript. +Not currently used." + :group 'js2-mode) + +(defface js2-private-function-call + '((t :foreground "goldenrod")) + "Face used to highlight calls to private functions in javascript. +Not currently used." + :group 'js2-mode) + +(defface js2-jsdoc-html-tag-name + '((((class color) (min-colors 88) (background light)) + (:foreground "rosybrown")) + (((class color) (min-colors 8) (background dark)) + (:foreground "yellow")) + (((class color) (min-colors 8) (background light)) + (:foreground "magenta"))) + "Face used to highlight jsdoc html tag names" + :group 'js2-mode) + +(defface js2-jsdoc-html-tag-delimiter + '((((class color) (min-colors 88) (background light)) + (:foreground "dark khaki")) + (((class color) (min-colors 8) (background dark)) + (:foreground "green")) + (((class color) (min-colors 8) (background light)) + (:foreground "green"))) + "Face used to highlight brackets in jsdoc html tags." + :group 'js2-mode) + +(defface js2-external-variable + '((t :foreground "orange")) + "Face used to highlight undeclared variable identifiers.") + +(defcustom js2-init-hook nil + ;; FIXME: We don't really need this anymore. + "List of functions to be called after `js2-mode' or +`js2-minor-mode' has initialized all variables, before parsing +the buffer for the first time." + :type 'hook + :group 'js2-mode + :version "20130608") + +(defcustom js2-post-parse-callbacks nil + "List of callback functions invoked after parsing finishes. +Currently, the main use for this function is to add synthetic +declarations to `js2-recorded-identifiers', which see." + :type 'hook + :group 'js2-mode) + +(defcustom js2-build-imenu-callbacks nil + "List of functions called during Imenu index generation. +It's a good place to add additional entries to it, using +`js2-record-imenu-entry'." + :type 'hook + :group 'js2-mode) + +(defcustom js2-highlight-external-variables t + "Non-nil to highlight undeclared variable identifiers. +An undeclared variable is any variable not declared with var or let +in the current scope or any lexically enclosing scope. If you use +such a variable, then you are either expecting it to originate from +another file, or you've got a potential bug." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-warn-about-unused-function-arguments nil + "Non-nil to treat function arguments like declared-but-unused variables." + :type 'booleanp + :group 'js2-mode) + +(defcustom js2-include-jslint-globals t + "Non-nil to include the identifiers from JSLint global +declaration (see http://www.jslint.com/help.html#global) in the +buffer-local externs list. See `js2-additional-externs' for more +information." + :type 'boolean + :group 'js2-mode) + +(defcustom js2-include-jslint-declaration-externs t + "Non-nil to include the identifiers JSLint assumes to be there +under certain declarations in the buffer-local externs list. See +`js2-additional-externs' for more information." + :type 'boolean + :group 'js2-mode) + +(defvar js2-mode-map + (let ((map (make-sparse-keymap))) + (define-key map [remap indent-new-comment-line] #'js2-line-break) + (define-key map (kbd "C-c C-e") #'js2-mode-hide-element) + (define-key map (kbd "C-c C-s") #'js2-mode-show-element) + (define-key map (kbd "C-c C-a") #'js2-mode-show-all) + (define-key map (kbd "C-c C-f") #'js2-mode-toggle-hide-functions) + (define-key map (kbd "C-c C-t") #'js2-mode-toggle-hide-comments) + (define-key map (kbd "C-c C-o") #'js2-mode-toggle-element) + (define-key map (kbd "C-c C-w") #'js2-mode-toggle-warnings-and-errors) + (define-key map [down-mouse-3] #'js2-down-mouse-3) + (define-key map [remap js-find-symbol] #'js2-jump-to-definition) + + (define-key map [menu-bar javascript] + (cons "JavaScript" (make-sparse-keymap "JavaScript"))) + + (define-key map [menu-bar javascript customize-js2-mode] + '(menu-item "Customize js2-mode" js2-mode-customize + :help "Customize the behavior of this mode")) + + (define-key map [menu-bar javascript js2-force-refresh] + '(menu-item "Force buffer refresh" js2-mode-reset + :help "Re-parse the buffer from scratch")) + + (define-key map [menu-bar javascript separator-2] + '("--")) + + (define-key map [menu-bar javascript next-error] + '(menu-item "Next warning or error" next-error + :enabled (and js2-mode-ast + (or (js2-ast-root-errors js2-mode-ast) + (js2-ast-root-warnings js2-mode-ast))) + :help "Move to next warning or error")) + + (define-key map [menu-bar javascript display-errors] + '(menu-item "Show errors and warnings" js2-mode-display-warnings-and-errors + :visible (not js2-mode-show-parse-errors) + :help "Turn on display of warnings and errors")) + + (define-key map [menu-bar javascript hide-errors] + '(menu-item "Hide errors and warnings" js2-mode-hide-warnings-and-errors + :visible js2-mode-show-parse-errors + :help "Turn off display of warnings and errors")) + + (define-key map [menu-bar javascript separator-1] + '("--")) + + (define-key map [menu-bar javascript js2-toggle-function] + '(menu-item "Show/collapse element" js2-mode-toggle-element + :help "Hide or show function body or comment")) + + (define-key map [menu-bar javascript show-comments] + '(menu-item "Show block comments" js2-mode-toggle-hide-comments + :visible js2-mode-comments-hidden + :help "Expand all hidden block comments")) + + (define-key map [menu-bar javascript hide-comments] + '(menu-item "Hide block comments" js2-mode-toggle-hide-comments + :visible (not js2-mode-comments-hidden) + :help "Show block comments as /*...*/")) + + (define-key map [menu-bar javascript show-all-functions] + '(menu-item "Show function bodies" js2-mode-toggle-hide-functions + :visible js2-mode-functions-hidden + :help "Expand all hidden function bodies")) + + (define-key map [menu-bar javascript hide-all-functions] + '(menu-item "Hide function bodies" js2-mode-toggle-hide-functions + :visible (not js2-mode-functions-hidden) + :help "Show {...} for all top-level function bodies")) + + map) + "Keymap used in `js2-mode' buffers.") + +(defcustom js2-bounce-indent-p nil + "Non-nil to bind `js2-indent-bounce' and `js2-indent-bounce-backward'. +They will augment the default indent-line behavior with cycling +among several computed alternatives. See the function +`js2-bounce-indent' for details. The above commands will be +bound to TAB and backtab." + :type 'boolean + :group 'js2-mode + :set (lambda (sym value) + (set-default sym value) + (let ((map js2-mode-map)) + (if (not value) + (progn + (define-key map "\t" nil) + (define-key map (kbd "<backtab>") nil)) + (define-key map "\t" #'js2-indent-bounce) + (define-key map (kbd "<backtab>") #'js2-indent-bounce-backward))))) + +(defconst js2-mode-identifier-re "[[:alpha:]_$][[:alnum:]_$]*") + +(defvar js2-mode-//-comment-re "^\\(\\s-*\\)//.+" + "Matches a //-comment line. Must be first non-whitespace on line. +First match-group is the leading whitespace.") + +(defvar js2-mode-hook nil) + +(js2-deflocal js2-mode-ast nil "Private variable.") +(js2-deflocal js2-mode-parse-timer nil "Private variable.") +(js2-deflocal js2-mode-buffer-dirty-p nil "Private variable.") +(js2-deflocal js2-mode-parsing nil "Private variable.") +(js2-deflocal js2-mode-node-overlay nil) + +(defvar js2-mode-show-overlay js2-mode-dev-mode-p + "Debug: Non-nil to highlight AST nodes on mouse-down.") + +(js2-deflocal js2-mode-fontifications nil "Private variable") +(js2-deflocal js2-mode-deferred-properties nil "Private variable") +(js2-deflocal js2-imenu-recorder nil "Private variable") +(js2-deflocal js2-imenu-function-map nil "Private variable") + +(defvar js2-mode-verbose-parse-p js2-mode-dev-mode-p + "Non-nil to emit status messages during parsing.") + +(defvar js2-mode-functions-hidden nil "Private variable.") +(defvar js2-mode-comments-hidden nil "Private variable.") + +(defvar js2-mode-syntax-table + (let ((table (make-syntax-table))) + (c-populate-syntax-table table) + (modify-syntax-entry ?` "\"" table) + table) + "Syntax table used in `js2-mode' buffers.") + +(defvar js2-mode-abbrev-table nil + "Abbrev table in use in `js2-mode' buffers.") +(define-abbrev-table 'js2-mode-abbrev-table ()) + +(defvar js2-mode-pending-parse-callbacks nil + "List of functions waiting to be notified that parse is finished.") + +(defvar js2-mode-last-indented-line -1) + +;;; Localizable error and warning messages + +;; Messages are copied from Rhino's Messages.properties. +;; Many of the Java-specific messages have been elided. +;; Add any js2-specific ones at the end, so we can keep +;; this file synced with changes to Rhino's. + +(defvar js2-message-table + (make-hash-table :test 'equal :size 250) + "Contains localized messages for `js2-mode'.") + +;; TODO(stevey): construct this table at compile-time. +(defmacro js2-msg (key &rest strings) + `(puthash ,key (concat ,@strings) + js2-message-table)) + +(defun js2-get-msg (msg-key) + "Look up a localized message. +MSG-KEY is a list of (MSG ARGS). If the message takes parameters, +the correct number of ARGS must be provided." + (let* ((key (if (listp msg-key) (car msg-key) msg-key)) + (args (if (listp msg-key) (cdr msg-key))) + (msg (gethash key js2-message-table))) + (if msg + (apply #'format msg args) + key))) ; default to showing the key + +(js2-msg "msg.dup.parms" + "Duplicate parameter name '%s'.") + +(js2-msg "msg.too.big.jump" + "Program too complex: jump offset too big.") + +(js2-msg "msg.too.big.index" + "Program too complex: internal index exceeds 64K limit.") + +(js2-msg "msg.while.compiling.fn" + "Encountered code generation error while compiling function '%s': %s") + +(js2-msg "msg.while.compiling.script" + "Encountered code generation error while compiling script: %s") + +;; Context +(js2-msg "msg.ctor.not.found" + "Constructor for '%s' not found.") + +(js2-msg "msg.not.ctor" + "'%s' is not a constructor.") + +;; FunctionObject +(js2-msg "msg.varargs.ctor" + "Method or constructor '%s' must be static " + "with the signature (Context cx, Object[] args, " + "Function ctorObj, boolean inNewExpr) " + "to define a variable arguments constructor.") + +(js2-msg "msg.varargs.fun" + "Method '%s' must be static with the signature " + "(Context cx, Scriptable thisObj, Object[] args, Function funObj) " + "to define a variable arguments function.") + +(js2-msg "msg.incompat.call" + "Method '%s' called on incompatible object.") + +(js2-msg "msg.bad.parms" + "Unsupported parameter type '%s' in method '%s'.") + +(js2-msg "msg.bad.method.return" + "Unsupported return type '%s' in method '%s'.") + +(js2-msg "msg.bad.ctor.return" + "Construction of objects of type '%s' is not supported.") + +(js2-msg "msg.no.overload" + "Method '%s' occurs multiple times in class '%s'.") + +(js2-msg "msg.method.not.found" + "Method '%s' not found in '%s'.") + +;; IRFactory + +(js2-msg "msg.bad.for.in.lhs" + "Invalid left-hand side of for..in loop.") + +(js2-msg "msg.mult.index" + "Only one variable allowed in for..in loop.") + +(js2-msg "msg.bad.for.in.destruct" + "Left hand side of for..in loop must be an array of " + "length 2 to accept key/value pair.") + +(js2-msg "msg.cant.convert" + "Can't convert to type '%s'.") + +(js2-msg "msg.bad.assign.left" + "Invalid assignment left-hand side.") + +(js2-msg "msg.bad.decr" + "Invalid decrement operand.") + +(js2-msg "msg.bad.incr" + "Invalid increment operand.") + +(js2-msg "msg.bad.yield" + "yield must be in a function.") + +(js2-msg "msg.bad.await" + "await must be in async functions.") + +;; NativeGlobal +(js2-msg "msg.cant.call.indirect" + "Function '%s' must be called directly, and not by way of a " + "function of another name.") + +(js2-msg "msg.eval.nonstring" + "Calling eval() with anything other than a primitive " + "string value will simply return the value. " + "Is this what you intended?") + +(js2-msg "msg.eval.nonstring.strict" + "Calling eval() with anything other than a primitive " + "string value is not allowed in strict mode.") + +(js2-msg "msg.bad.destruct.op" + "Invalid destructuring assignment operator") + +;; NativeCall +(js2-msg "msg.only.from.new" + "'%s' may only be invoked from a `new' expression.") + +(js2-msg "msg.deprec.ctor" + "The '%s' constructor is deprecated.") + +;; NativeFunction +(js2-msg "msg.no.function.ref.found" + "no source found to decompile function reference %s") + +(js2-msg "msg.arg.isnt.array" + "second argument to Function.prototype.apply must be an array") + +;; NativeGlobal +(js2-msg "msg.bad.esc.mask" + "invalid string escape mask") + +;; NativeRegExp +(js2-msg "msg.bad.quant" + "Invalid quantifier %s") + +(js2-msg "msg.overlarge.backref" + "Overly large back reference %s") + +(js2-msg "msg.overlarge.min" + "Overly large minimum %s") + +(js2-msg "msg.overlarge.max" + "Overly large maximum %s") + +(js2-msg "msg.zero.quant" + "Zero quantifier %s") + +(js2-msg "msg.max.lt.min" + "Maximum %s less than minimum") + +(js2-msg "msg.unterm.quant" + "Unterminated quantifier %s") + +(js2-msg "msg.unterm.paren" + "Unterminated parenthetical %s") + +(js2-msg "msg.unterm.class" + "Unterminated character class %s") + +(js2-msg "msg.bad.range" + "Invalid range in character class.") + +(js2-msg "msg.trail.backslash" + "Trailing \\ in regular expression.") + +(js2-msg "msg.re.unmatched.right.paren" + "unmatched ) in regular expression.") + +(js2-msg "msg.no.regexp" + "Regular expressions are not available.") + +(js2-msg "msg.bad.backref" + "back-reference exceeds number of capturing parentheses.") + +(js2-msg "msg.bad.regexp.compile" + "Only one argument may be specified if the first " + "argument to RegExp.prototype.compile is a RegExp object.") + +;; Parser +(js2-msg "msg.got.syntax.errors" + "Compilation produced %s syntax errors.") + +(js2-msg "msg.var.redecl" + "Redeclaration of var %s.") + +(js2-msg "msg.const.redecl" + "TypeError: redeclaration of const %s.") + +(js2-msg "msg.let.redecl" + "TypeError: redeclaration of variable %s.") + +(js2-msg "msg.parm.redecl" + "TypeError: redeclaration of formal parameter %s.") + +(js2-msg "msg.fn.redecl" + "TypeError: redeclaration of function %s.") + +(js2-msg "msg.let.decl.not.in.block" + "SyntaxError: let declaration not directly within block") + +(js2-msg "msg.mod.import.decl.at.top.level" + "SyntaxError: import declarations may only appear at the top level") + +(js2-msg "msg.mod.as.after.reserved.word" + "SyntaxError: missing keyword 'as' after reserved word %s") + +(js2-msg "msg.mod.rc.after.import.spec.list" + "SyntaxError: missing '}' after module specifier list") + +(js2-msg "msg.mod.from.after.import.spec.set" + "SyntaxError: missing keyword 'from' after import specifier set") + +(js2-msg "msg.mod.declaration.after.import" + "SyntaxError: missing declaration after 'import' keyword") + +(js2-msg "msg.mod.spec.after.from" + "SyntaxError: missing module specifier after 'from' keyword") + +(js2-msg "msg.mod.export.decl.at.top.level" + "SyntaxError: export declarations may only appear at top level") + +(js2-msg "msg.mod.rc.after.export.spec.list" + "SyntaxError: missing '}' after export specifier list") + +;; NodeTransformer +(js2-msg "msg.dup.label" + "duplicated label") + +(js2-msg "msg.undef.label" + "undefined label") + +(js2-msg "msg.bad.break" + "unlabelled break must be inside loop or switch") + +(js2-msg "msg.continue.outside" + "continue must be inside loop") + +(js2-msg "msg.continue.nonloop" + "continue can only use labels of iteration statements") + +(js2-msg "msg.bad.throw.eol" + "Line terminator is not allowed between the throw " + "keyword and throw expression.") + +(js2-msg "msg.unnamed.function.stmt" ; added by js2-mode + "function statement requires a name") + +(js2-msg "msg.no.paren.parms" + "missing ( before function parameters.") + +(js2-msg "msg.no.parm" + "missing formal parameter") + +(js2-msg "msg.no.paren.after.parms" + "missing ) after formal parameters") + +(js2-msg "msg.no.default.after.default.param" ; added by js2-mode + "parameter without default follows parameter with default") + +(js2-msg "msg.param.after.rest" ; added by js2-mode + "parameter after rest parameter") + +(js2-msg "msg.bad.arrow.args" ; added by js2-mode + "invalid arrow-function arguments (parentheses around the arrow-function may help)") + +(js2-msg "msg.no.brace.body" + "missing '{' before function body") + +(js2-msg "msg.no.brace.after.body" + "missing } after function body") + +(js2-msg "msg.no.paren.cond" + "missing ( before condition") + +(js2-msg "msg.no.paren.after.cond" + "missing ) after condition") + +(js2-msg "msg.no.semi.stmt" + "missing ; before statement") + +(js2-msg "msg.missing.semi" + "missing ; after statement") + +(js2-msg "msg.no.name.after.dot" + "missing name after . operator") + +(js2-msg "msg.no.name.after.coloncolon" + "missing name after :: operator") + +(js2-msg "msg.no.name.after.dotdot" + "missing name after .. operator") + +(js2-msg "msg.no.name.after.xmlAttr" + "missing name after .@") + +(js2-msg "msg.no.bracket.index" + "missing ] in index expression") + +(js2-msg "msg.no.paren.switch" + "missing ( before switch expression") + +(js2-msg "msg.no.paren.after.switch" + "missing ) after switch expression") + +(js2-msg "msg.no.brace.switch" + "missing '{' before switch body") + +(js2-msg "msg.bad.switch" + "invalid switch statement") + +(js2-msg "msg.no.colon.case" + "missing : after case expression") + +(js2-msg "msg.double.switch.default" + "double default label in the switch statement") + +(js2-msg "msg.no.while.do" + "missing while after do-loop body") + +(js2-msg "msg.no.paren.for" + "missing ( after for") + +(js2-msg "msg.no.semi.for" + "missing ; after for-loop initializer") + +(js2-msg "msg.no.semi.for.cond" + "missing ; after for-loop condition") + +(js2-msg "msg.in.after.for.name" + "missing in or of after for") + +(js2-msg "msg.no.paren.for.ctrl" + "missing ) after for-loop control") + +(js2-msg "msg.no.paren.with" + "missing ( before with-statement object") + +(js2-msg "msg.no.paren.after.with" + "missing ) after with-statement object") + +(js2-msg "msg.no.with.strict" + "with statements not allowed in strict mode") + +(js2-msg "msg.no.paren.after.let" + "missing ( after let") + +(js2-msg "msg.no.paren.let" + "missing ) after variable list") + +(js2-msg "msg.no.curly.let" + "missing } after let statement") + +(js2-msg "msg.bad.return" + "invalid return") + +(js2-msg "msg.no.brace.block" + "missing } in compound statement") + +(js2-msg "msg.bad.label" + "invalid label") + +(js2-msg "msg.bad.var" + "missing variable name") + +(js2-msg "msg.bad.var.init" + "invalid variable initialization") + +(js2-msg "msg.no.colon.cond" + "missing : in conditional expression") + +(js2-msg "msg.no.paren.arg" + "missing ) after argument list") + +(js2-msg "msg.no.bracket.arg" + "missing ] after element list") + +(js2-msg "msg.bad.prop" + "invalid property id") + +(js2-msg "msg.no.colon.prop" + "missing : after property id") + +(js2-msg "msg.no.brace.prop" + "missing } after property list") + +(js2-msg "msg.no.paren" + "missing ) in parenthetical") + +(js2-msg "msg.reserved.id" + "'%s' is a reserved identifier") + +(js2-msg "msg.no.paren.catch" + "missing ( before catch-block condition") + +(js2-msg "msg.bad.catchcond" + "invalid catch block condition") + +(js2-msg "msg.catch.unreachable" + "any catch clauses following an unqualified catch are unreachable") + +(js2-msg "msg.no.brace.try" + "missing '{' before try block") + +(js2-msg "msg.no.brace.catchblock" + "missing '{' before catch-block body") + +(js2-msg "msg.try.no.catchfinally" + "'try' without 'catch' or 'finally'") + +(js2-msg "msg.no.return.value" + "function %s does not always return a value") + +(js2-msg "msg.anon.no.return.value" + "anonymous function does not always return a value") + +(js2-msg "msg.return.inconsistent" + "return statement is inconsistent with previous usage") + +(js2-msg "msg.generator.returns" + "TypeError: legacy generator function '%s' returns a value") + +(js2-msg "msg.anon.generator.returns" + "TypeError: anonymous legacy generator function returns a value") + +(js2-msg "msg.syntax" + "syntax error") + +(js2-msg "msg.unexpected.eof" + "Unexpected end of file") + +(js2-msg "msg.XML.bad.form" + "illegally formed XML syntax") + +(js2-msg "msg.XML.not.available" + "XML runtime not available") + +(js2-msg "msg.too.deep.parser.recursion" + "Too deep recursion while parsing") + +(js2-msg "msg.no.side.effects" + "Code has no side effects") + +(js2-msg "msg.extra.trailing.comma" + "Trailing comma is not supported in some browsers") + +(js2-msg "msg.array.trailing.comma" + "Trailing comma yields different behavior across browsers") + +(js2-msg "msg.equal.as.assign" + (concat "Test for equality (==) mistyped as assignment (=)?" + " (parenthesize to suppress warning)")) + +(js2-msg "msg.var.hides.arg" + "Variable %s hides argument") + +(js2-msg "msg.destruct.assign.no.init" + "Missing = in destructuring declaration") + +(js2-msg "msg.init.no.destruct" + "Binding initializer not in destructuring assignment") + +(js2-msg "msg.no.octal.strict" + "Octal numbers prohibited in strict mode.") + +(js2-msg "msg.dup.obj.lit.prop.strict" + "Property '%s' already defined in this object literal.") + +(js2-msg "msg.dup.param.strict" + "Parameter '%s' already declared in this function.") + +(js2-msg "msg.bad.id.strict" + "'%s' is not a valid identifier for this use in strict mode.") + +;; ScriptRuntime +(js2-msg "msg.no.properties" + "%s has no properties.") + +(js2-msg "msg.invalid.iterator" + "Invalid iterator value") + +(js2-msg "msg.iterator.primitive" + "__iterator__ returned a primitive value") + +(js2-msg "msg.assn.create.strict" + "Assignment to undeclared variable %s") + +(js2-msg "msg.undeclared.variable" ; added by js2-mode + "Undeclared variable or function '%s'") + +(js2-msg "msg.unused.variable" ; added by js2-mode + "Unused variable or function '%s'") + +(js2-msg "msg.uninitialized.variable" ; added by js2-mode + "Variable '%s' referenced but never initialized") + +(js2-msg "msg.ref.undefined.prop" + "Reference to undefined property '%s'") + +(js2-msg "msg.prop.not.found" + "Property %s not found.") + +(js2-msg "msg.invalid.type" + "Invalid JavaScript value of type %s") + +(js2-msg "msg.primitive.expected" + "Primitive type expected (had %s instead)") + +(js2-msg "msg.namespace.expected" + "Namespace object expected to left of :: (found %s instead)") + +(js2-msg "msg.null.to.object" + "Cannot convert null to an object.") + +(js2-msg "msg.undef.to.object" + "Cannot convert undefined to an object.") + +(js2-msg "msg.cyclic.value" + "Cyclic %s value not allowed.") + +(js2-msg "msg.is.not.defined" + "'%s' is not defined.") + +(js2-msg "msg.undef.prop.read" + "Cannot read property '%s' from %s") + +(js2-msg "msg.undef.prop.write" + "Cannot set property '%s' of %s to '%s'") + +(js2-msg "msg.undef.prop.delete" + "Cannot delete property '%s' of %s") + +(js2-msg "msg.undef.method.call" + "Cannot call method '%s' of %s") + +(js2-msg "msg.undef.with" + "Cannot apply 'with' to %s") + +(js2-msg "msg.isnt.function" + "%s is not a function, it is %s.") + +(js2-msg "msg.isnt.function.in" + "Cannot call property %s in object %s. " + "It is not a function, it is '%s'.") + +(js2-msg "msg.function.not.found" + "Cannot find function %s.") + +(js2-msg "msg.function.not.found.in" + "Cannot find function %s in object %s.") + +(js2-msg "msg.isnt.xml.object" + "%s is not an xml object.") + +(js2-msg "msg.no.ref.to.get" + "%s is not a reference to read reference value.") + +(js2-msg "msg.no.ref.to.set" + "%s is not a reference to set reference value to %s.") + +(js2-msg "msg.no.ref.from.function" + "Function %s can not be used as the left-hand " + "side of assignment or as an operand of ++ or -- operator.") + +(js2-msg "msg.bad.default.value" + "Object's getDefaultValue() method returned an object.") + +(js2-msg "msg.instanceof.not.object" + "Can't use instanceof on a non-object.") + +(js2-msg "msg.instanceof.bad.prototype" + "'prototype' property of %s is not an object.") + +(js2-msg "msg.bad.radix" + "illegal radix %s.") + +;; ScriptableObject +(js2-msg "msg.default.value" + "Cannot find default value for object.") + +(js2-msg "msg.zero.arg.ctor" + "Cannot load class '%s' which has no zero-parameter constructor.") + +(js2-msg "msg.ctor.multiple.parms" + "Can't define constructor or class %s since more than " + "one constructor has multiple parameters.") + +(js2-msg "msg.extend.scriptable" + "%s must extend ScriptableObject in order to define property %s.") + +(js2-msg "msg.bad.getter.parms" + "In order to define a property, getter %s must have zero " + "parameters or a single ScriptableObject parameter.") + +(js2-msg "msg.obj.getter.parms" + "Expected static or delegated getter %s to take " + "a ScriptableObject parameter.") + +(js2-msg "msg.getter.static" + "Getter and setter must both be static or neither be static.") + +(js2-msg "msg.setter.return" + "Setter must have void return type: %s") + +(js2-msg "msg.setter2.parms" + "Two-parameter setter must take a ScriptableObject as " + "its first parameter.") + +(js2-msg "msg.setter1.parms" + "Expected single parameter setter for %s") + +(js2-msg "msg.setter2.expected" + "Expected static or delegated setter %s to take two parameters.") + +(js2-msg "msg.setter.parms" + "Expected either one or two parameters for setter.") + +(js2-msg "msg.setter.bad.type" + "Unsupported parameter type '%s' in setter '%s'.") + +(js2-msg "msg.add.sealed" + "Cannot add a property to a sealed object: %s.") + +(js2-msg "msg.remove.sealed" + "Cannot remove a property from a sealed object: %s.") + +(js2-msg "msg.modify.sealed" + "Cannot modify a property of a sealed object: %s.") + +(js2-msg "msg.modify.readonly" + "Cannot modify readonly property: %s.") + +;; TokenStream +(js2-msg "msg.missing.exponent" + "missing exponent") + +(js2-msg "msg.caught.nfe" + "number format error") + +(js2-msg "msg.unterminated.string.lit" + "unterminated string literal") + +(js2-msg "msg.unterminated.comment" + "unterminated comment") + +(js2-msg "msg.unterminated.re.lit" + "unterminated regular expression literal") + +(js2-msg "msg.invalid.re.flag" + "invalid flag after regular expression") + +(js2-msg "msg.no.re.input.for" + "no input for %s") + +(js2-msg "msg.illegal.character" + "illegal character") + +(js2-msg "msg.invalid.escape" + "invalid Unicode escape sequence") + +(js2-msg "msg.bad.namespace" + "not a valid default namespace statement. " + "Syntax is: default xml namespace = EXPRESSION;") + +;; TokensStream warnings +(js2-msg "msg.bad.octal.literal" + "illegal octal literal digit %s; " + "interpreting it as a decimal digit") + +(js2-msg "msg.missing.hex.digits" + "missing hexadecimal digits after '0x'") + +(js2-msg "msg.missing.binary.digits" + "missing binary digits after '0b'") + +(js2-msg "msg.missing.octal.digits" + "missing octal digits after '0o'") + +(js2-msg "msg.script.is.not.constructor" + "Script objects are not constructors.") + +;; Arrays +(js2-msg "msg.arraylength.bad" + "Inappropriate array length.") + +;; Arrays +(js2-msg "msg.arraylength.too.big" + "Array length %s exceeds supported capacity limit.") + +;; URI +(js2-msg "msg.bad.uri" + "Malformed URI sequence.") + +;; Number +(js2-msg "msg.bad.precision" + "Precision %s out of range.") + +;; NativeGenerator +(js2-msg "msg.send.newborn" + "Attempt to send value to newborn generator") + +(js2-msg "msg.already.exec.gen" + "Already executing generator") + +(js2-msg "msg.StopIteration.invalid" + "StopIteration may not be changed to an arbitrary object.") + +;; Interpreter +(js2-msg "msg.yield.closing" + "Yield from closing generator") + +;; Classes +(js2-msg "msg.unnamed.class.stmt" ; added by js2-mode + "class statement requires a name") + +(js2-msg "msg.class.unexpected.comma" ; added by js2-mode + "unexpected ',' between class properties") + +(js2-msg "msg.unexpected.static" ; added by js2-mode + "unexpected 'static'") + +(js2-msg "msg.missing.extends" ; added by js2-mode + "name is required after extends") + +(js2-msg "msg.no.brace.class" ; added by js2-mode + "missing '{' before class body") + +(js2-msg "msg.missing.computed.rb" ; added by js2-mode + "missing ']' after computed property expression") + +;;; Tokens Buffer + +(defconst js2-ti-max-lookahead 2) +(defconst js2-ti-ntokens (1+ js2-ti-max-lookahead)) + +(defun js2-new-token (offset) + (let ((token (make-js2-token (+ offset js2-ts-cursor)))) + (setq js2-ti-tokens-cursor (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens)) + (aset js2-ti-tokens js2-ti-tokens-cursor token) + token)) + +(defsubst js2-current-token () + (aref js2-ti-tokens js2-ti-tokens-cursor)) + +(defsubst js2-current-token-string () + (js2-token-string (js2-current-token))) + +(defsubst js2-current-token-type () + (js2-token-type (js2-current-token))) + +(defsubst js2-current-token-beg () + (js2-token-beg (js2-current-token))) + +(defsubst js2-current-token-end () + (js2-token-end (js2-current-token))) + +(defun js2-current-token-len () + (let ((token (js2-current-token))) + (- (js2-token-end token) + (js2-token-beg token)))) + +(defun js2-ts-seek (state) + (setq js2-ts-lineno (js2-ts-state-lineno state) + js2-ts-cursor (js2-ts-state-cursor state) + js2-ti-tokens (js2-ts-state-tokens state) + js2-ti-tokens-cursor (js2-ts-state-tokens-cursor state) + js2-ti-lookahead (js2-ts-state-lookahead state))) + +;;; Utilities + +(defun js2-delete-if (predicate list) + "Remove all items satisfying PREDICATE in LIST." + (cl-loop for item in list + if (not (funcall predicate item)) + collect item)) + +(defun js2-position (element list) + "Find 0-indexed position of ELEMENT in LIST comparing with `eq'. +Returns nil if element is not found in the list." + (let ((count 0) + found) + (while (and list (not found)) + (if (eq element (car list)) + (setq found t) + (setq count (1+ count) + list (cdr list)))) + (if found count))) + +(defun js2-find-if (predicate list) + "Find first item satisfying PREDICATE in LIST." + (let (result) + (while (and list (not result)) + (if (funcall predicate (car list)) + (setq result (car list))) + (setq list (cdr list))) + result)) + +(defmacro js2-time (form) + "Evaluate FORM, discard result, and return elapsed time in sec." + (declare (debug t)) + (let ((beg (make-symbol "--js2-time-beg--"))) + `(let ((,beg (current-time))) + ,form + (/ (truncate (* (- (float-time (current-time)) + (float-time ,beg)) + 10000)) + 10000.0)))) + +(defsubst js2-same-line (pos) + "Return t if POS is on the same line as current point." + (and (>= pos (point-at-bol)) + (<= pos (point-at-eol)))) + +(defun js2-code-bug () + "Signal an error when we encounter an unexpected code path." + (error "failed assertion")) + +(defsubst js2-record-text-property (beg end prop value) + "Record a text property to set when parsing finishes." + (push (list beg end prop value) js2-mode-deferred-properties)) + +;; I'd like to associate errors with nodes, but for now the +;; easiest thing to do is get the context info from the last token. +(defun js2-record-parse-error (msg &optional arg pos len) + (push (list (list msg arg) + (or pos (js2-current-token-beg)) + (or len (js2-current-token-len))) + js2-parsed-errors)) + +(defun js2-report-error (msg &optional msg-arg pos len) + "Signal a syntax error or record a parse error." + (if js2-recover-from-parse-errors + (js2-record-parse-error msg msg-arg pos len) + (signal 'js2-syntax-error + (list msg + js2-ts-lineno + (save-excursion + (goto-char js2-ts-cursor) + (current-column)) + js2-ts-hit-eof)))) + +(defun js2-report-warning (msg &optional msg-arg pos len face) + (if js2-compiler-report-warning-as-error + (js2-report-error msg msg-arg pos len) + (push (list (list msg msg-arg) + (or pos (js2-current-token-beg)) + (or len (js2-current-token-len)) + face) + js2-parsed-warnings))) + +(defun js2-add-strict-warning (msg-id &optional msg-arg beg end) + (if js2-compiler-strict-mode + (js2-report-warning msg-id msg-arg beg + (and beg end (- end beg))))) + +(put 'js2-syntax-error 'error-conditions + '(error syntax-error js2-syntax-error)) +(put 'js2-syntax-error 'error-message "Syntax error") + +(put 'js2-parse-error 'error-conditions + '(error parse-error js2-parse-error)) +(put 'js2-parse-error 'error-message "Parse error") + +(defmacro js2-clear-flag (flags flag) + `(setq ,flags (logand ,flags (lognot ,flag)))) + +(defmacro js2-set-flag (flags flag) + "Logical-or FLAG into FLAGS." + `(setq ,flags (logior ,flags ,flag))) + +(defsubst js2-flag-set-p (flags flag) + (/= 0 (logand flags flag))) + +(defsubst js2-flag-not-set-p (flags flag) + (zerop (logand flags flag))) + +;;; AST struct and function definitions + +;; flags for ast node property 'member-type (used for e4x operators) +(defvar js2-property-flag #x1 "Property access: element is valid name.") +(defvar js2-attribute-flag #x2 "x.@y or x..@y.") +(defvar js2-descendants-flag #x4 "x..y or x..@i.") + +(defsubst js2-relpos (pos anchor) + "Convert POS to be relative to ANCHOR. +If POS is nil, returns nil." + (and pos (- pos anchor))) + +(defun js2-make-pad (indent) + (if (zerop indent) + "" + (make-string (* indent js2-basic-offset) ? ))) + +(defun js2-visit-ast (node callback) + "Visit every node in ast NODE with visitor CALLBACK. + +CALLBACK is a function that takes two arguments: (NODE END-P). It is +called twice: once to visit the node, and again after all the node's +children have been processed. The END-P argument is nil on the first +call and non-nil on the second call. The return value of the callback +affects the traversal: if non-nil, the children of NODE are processed. +If the callback returns nil, or if the node has no children, then the +callback is called immediately with a non-nil END-P argument. + +The node traversal is approximately lexical-order, although there +are currently no guarantees around this." + (when node + (let ((vfunc (get (aref node 0) 'js2-visitor))) + ;; visit the node + (when (funcall callback node nil) + ;; visit the kids + (cond + ((eq vfunc 'js2-visit-none) + nil) ; don't even bother calling it + ;; Each AST node type has to define a `js2-visitor' function + ;; that takes a node and a callback, and calls `js2-visit-ast' + ;; on each child of the node. + (vfunc + (funcall vfunc node callback)) + (t + (error "%s does not define a visitor-traversal function" + (aref node 0))))) + ;; call the end-visit + (funcall callback node t)))) + +(cl-defstruct (js2-node + (:constructor nil)) ; abstract + "Base AST node type." + (type -1) ; token type + (pos -1) ; start position of this AST node in parsed input + (len 1) ; num characters spanned by the node + props ; optional node property list (an alist) + parent) ; link to parent node; null for root + +(defsubst js2-node-get-prop (node prop &optional default) + (or (cadr (assoc prop (js2-node-props node))) default)) + +(defsubst js2-node-set-prop (node prop value) + (setf (js2-node-props node) + (cons (list prop value) (js2-node-props node)))) + +(defun js2-fixup-starts (n nodes) + "Adjust the start positions of NODES to be relative to N. +Any node in the list may be nil, for convenience." + (dolist (node nodes) + (when node + (setf (js2-node-pos node) (- (js2-node-pos node) + (js2-node-pos n)))))) + +(defun js2-node-add-children (parent &rest nodes) + "Set parent node of NODES to PARENT, and return PARENT. +Does nothing if we're not recording parent links. +If any given node in NODES is nil, doesn't record that link." + (js2-fixup-starts parent nodes) + (dolist (node nodes) + (and node + (setf (js2-node-parent node) parent)))) + +;; Non-recursive since it's called a frightening number of times. +(defun js2-node-abs-pos (n) + (let ((pos (js2-node-pos n))) + (while (setq n (js2-node-parent n)) + (setq pos (+ pos (js2-node-pos n)))) + pos)) + +(defsubst js2-node-abs-end (n) + "Return absolute buffer position of end of N." + (+ (js2-node-abs-pos n) (js2-node-len n))) + +(defun js2--struct-put (name key value) + (put name key value) + (put (intern (format "cl-struct-%s" name)) key value)) + +;; It's important to make sure block nodes have a Lisp list for the +;; child nodes, to limit printing recursion depth in an AST that +;; otherwise consists of defstruct vectors. Emacs will crash printing +;; a sufficiently large vector tree. + +(cl-defstruct (js2-block-node + (:include js2-node) + (:constructor make-js2-block-node (&key (type js2-BLOCK) + (pos (js2-current-token-beg)) + len + props + kids))) + "A block of statements." + kids) ; a Lisp list of the child statement nodes + +(js2--struct-put 'js2-block-node 'js2-visitor 'js2-visit-block) +(js2--struct-put 'js2-block-node 'js2-printer 'js2-print-block) + +(defun js2-visit-block (ast callback) + "Visit the `js2-block-node' children of AST." + (dolist (kid (js2-block-node-kids ast)) + (js2-visit-ast kid callback))) + +(defun js2-print-block (n i) + (let ((pad (js2-make-pad i))) + (insert pad "{\n") + (dolist (kid (js2-block-node-kids n)) + (js2-print-ast kid (1+ i))) + (insert pad "}"))) + +(cl-defstruct (js2-scope + (:include js2-block-node) + (:constructor make-js2-scope (&key (type js2-BLOCK) + (pos (js2-current-token-beg)) + len + kids))) + ;; The symbol-table is a LinkedHashMap<String,Symbol> in Rhino. + ;; I don't have one of those handy, so I'll use an alist for now. + ;; It's as fast as an emacs hashtable for up to about 50 elements, + ;; and is much lighter-weight to construct (both CPU and mem). + ;; The keys are interned strings (symbols) for faster lookup. + ;; Should switch to hybrid alist/hashtable eventually. + symbol-table ; an alist of (symbol . js2-symbol) + parent-scope ; a `js2-scope' + top) ; top-level `js2-scope' (script/function) + +(js2--struct-put 'js2-scope 'js2-visitor 'js2-visit-block) +(js2--struct-put 'js2-scope 'js2-printer 'js2-print-none) + +(defun js2-node-get-enclosing-scope (node) + "Return the innermost `js2-scope' node surrounding NODE. +Returns nil if there is no enclosing scope node." + (while (and (setq node (js2-node-parent node)) + (not (js2-scope-p node)))) + node) + +(defun js2-get-defining-scope (scope name &optional point) + "Search up scope chain from SCOPE looking for NAME, a string or symbol. +Returns `js2-scope' in which NAME is defined, or nil if not found. + +If POINT is non-nil, and if the found declaration type is +`js2-LET', also check that the declaration node is before POINT." + (let ((sym (if (symbolp name) + name + (intern name))) + result + (continue t)) + (while (and scope continue) + (if (or + (let ((entry (cdr (assq sym (js2-scope-symbol-table scope))))) + (and entry + (or (not point) + (not (eq js2-LET (js2-symbol-decl-type entry))) + (>= point + (js2-node-abs-pos (js2-symbol-ast-node entry)))))) + (and (eq sym 'arguments) + (js2-function-node-p scope))) + (setq continue nil + result scope) + (setq scope (js2-scope-parent-scope scope)))) + result)) + +(defun js2-scope-get-symbol (scope name) + "Return symbol table entry for NAME in SCOPE. +NAME can be a string or symbol. Returns a `js2-symbol' or nil if not found." + (and (js2-scope-symbol-table scope) + (cdr (assq (if (symbolp name) + name + (intern name)) + (js2-scope-symbol-table scope))))) + +(defun js2-scope-put-symbol (scope name symbol) + "Enter SYMBOL into symbol-table for SCOPE under NAME. +NAME can be a Lisp symbol or string. SYMBOL is a `js2-symbol'." + (let* ((table (js2-scope-symbol-table scope)) + (sym (if (symbolp name) name (intern name))) + (entry (assq sym table))) + (if entry + (setcdr entry symbol) + (push (cons sym symbol) + (js2-scope-symbol-table scope))))) + +(cl-defstruct (js2-symbol + (:constructor make-js2-symbol (decl-type name &optional ast-node))) + "A symbol table entry." + ;; One of js2-FUNCTION, js2-LP (for parameters), js2-VAR, + ;; js2-LET, or js2-CONST + decl-type + name ; string + ast-node) ; a `js2-node' + +(cl-defstruct (js2-error-node + (:include js2-node) + (:constructor make-js2-error-node (&key (type js2-ERROR) + (pos (js2-current-token-beg)) + len))) + "AST node representing a parse error.") + +(js2--struct-put 'js2-error-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-error-node 'js2-printer 'js2-print-none) + +(cl-defstruct (js2-script-node + (:include js2-scope) + (:constructor make-js2-script-node (&key (type js2-SCRIPT) + (pos (js2-current-token-beg)) + len))) + functions ; Lisp list of nested functions + regexps ; Lisp list of (string . flags) + symbols ; alist (every symbol gets unique index) + (param-count 0) + var-names ; vector of string names + consts ; bool-vector matching var-decls + (temp-number 0)) ; for generating temp variables + +(js2--struct-put 'js2-script-node 'js2-visitor 'js2-visit-block) +(js2--struct-put 'js2-script-node 'js2-printer 'js2-print-script) + +(defun js2-print-script (node indent) + (dolist (kid (js2-block-node-kids node)) + (js2-print-ast kid indent))) + +(cl-defstruct (js2-ast-root + (:include js2-script-node) + (:constructor make-js2-ast-root (&key (type js2-SCRIPT) + (pos (js2-current-token-beg)) + len + buffer))) + "The root node of a js2 AST." + buffer ; the source buffer from which the code was parsed + comments ; a Lisp list of comments, ordered by start position + errors ; a Lisp list of errors found during parsing + warnings ; a Lisp list of warnings found during parsing + node-count) ; number of nodes in the tree, including the root + +(js2--struct-put 'js2-ast-root 'js2-visitor 'js2-visit-ast-root) +(js2--struct-put 'js2-ast-root 'js2-printer 'js2-print-script) + +(defun js2-visit-ast-root (ast callback) + (dolist (kid (js2-ast-root-kids ast)) + (js2-visit-ast kid callback)) + (dolist (comment (js2-ast-root-comments ast)) + (js2-visit-ast comment callback))) + +(cl-defstruct (js2-comment-node + (:include js2-node) + (:constructor make-js2-comment-node (&key (type js2-COMMENT) + (pos (js2-current-token-beg)) + len + format))) + format) ; 'line, 'block, 'jsdoc or 'html + +(js2--struct-put 'js2-comment-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-comment-node 'js2-printer 'js2-print-comment) + +(defun js2-print-comment (n i) + ;; We really ought to link end-of-line comments to their nodes. + ;; Or maybe we could add a new comment type, 'endline. + (insert (js2-make-pad i) + (js2-node-string n))) + +(cl-defstruct (js2-expr-stmt-node + (:include js2-node) + (:constructor make-js2-expr-stmt-node (&key (type js2-EXPR_VOID) + (pos js2-ts-cursor) + len + expr))) + "An expression statement." + expr) + +(defsubst js2-expr-stmt-node-set-has-result (node) + "Change NODE type to `js2-EXPR_RESULT'. Used for code generation." + (setf (js2-node-type node) js2-EXPR_RESULT)) + +(js2--struct-put 'js2-expr-stmt-node 'js2-visitor 'js2-visit-expr-stmt-node) +(js2--struct-put 'js2-expr-stmt-node 'js2-printer 'js2-print-expr-stmt-node) + +(defun js2-visit-expr-stmt-node (n v) + (js2-visit-ast (js2-expr-stmt-node-expr n) v)) + +(defun js2-print-expr-stmt-node (n indent) + (js2-print-ast (js2-expr-stmt-node-expr n) indent) + (insert ";\n")) + +(cl-defstruct (js2-loop-node + (:include js2-scope) + (:constructor nil)) + "Abstract supertype of loop nodes." + body ; a `js2-block-node' + lp ; position of left-paren, nil if omitted + rp) ; position of right-paren, nil if omitted + +(cl-defstruct (js2-do-node + (:include js2-loop-node) + (:constructor make-js2-do-node (&key (type js2-DO) + (pos (js2-current-token-beg)) + len + body + condition + while-pos + lp + rp))) + "AST node for do-loop." + condition ; while (expression) + while-pos) ; buffer position of 'while' keyword + +(js2--struct-put 'js2-do-node 'js2-visitor 'js2-visit-do-node) +(js2--struct-put 'js2-do-node 'js2-printer 'js2-print-do-node) + +(defun js2-visit-do-node (n v) + (js2-visit-ast (js2-do-node-body n) v) + (js2-visit-ast (js2-do-node-condition n) v)) + +(defun js2-print-do-node (n i) + (let ((pad (js2-make-pad i))) + (insert pad "do {\n") + (dolist (kid (js2-block-node-kids (js2-do-node-body n))) + (js2-print-ast kid (1+ i))) + (insert pad "} while (") + (js2-print-ast (js2-do-node-condition n) 0) + (insert ");\n"))) + +(cl-defstruct (js2-export-node + (:include js2-node) + (:constructor make-js2-export-node (&key (type js2-EXPORT) + (pos (js2-current-token-beg)) + len + exports-list + from-clause + declaration + default))) + "AST node for an export statement. There are many things that can be exported, +so many of its properties will be nil. +" + exports-list ; lisp list of js2-export-binding-node to export + from-clause ; js2-from-clause-node for re-exporting symbols from another module + declaration ; js2-var-decl-node (var, let, const) or js2-class-node + default) ; js2-function-node or js2-assign-node + +(js2--struct-put 'js2-export-node 'js2-visitor 'js2-visit-export-node) +(js2--struct-put 'js2-export-node 'js2-printer 'js2-print-export-node) + +(defun js2-visit-export-node (n v) + (let ((exports-list (js2-export-node-exports-list n)) + (from (js2-export-node-from-clause n)) + (declaration (js2-export-node-declaration n)) + (default (js2-export-node-default n))) + (when exports-list + (dolist (export exports-list) + (js2-visit-ast export v))) + (when from + (js2-visit-ast from v)) + (when declaration + (js2-visit-ast declaration v)) + (when default + (js2-visit-ast default v)))) + +(defun js2-print-export-node (n i) + (let ((pad (js2-make-pad i)) + (exports-list (js2-export-node-exports-list n)) + (from (js2-export-node-from-clause n)) + (declaration (js2-export-node-declaration n)) + (default (js2-export-node-default n))) + (insert pad "export ") + (cond + (default + (insert "default ") + (js2-print-ast default i)) + (declaration + (js2-print-ast declaration i)) + ((and exports-list from) + (js2-print-named-imports exports-list) + (insert " ") + (js2-print-from-clause from)) + (from + (insert "* ") + (js2-print-from-clause from)) + (exports-list + (js2-print-named-imports exports-list))) + (unless (or (and default (not (js2-assign-node-p default))) + (and declaration (or (js2-function-node-p declaration) + (js2-class-node-p declaration)))) + (insert ";\n")))) + +(cl-defstruct (js2-while-node + (:include js2-loop-node) + (:constructor make-js2-while-node (&key (type js2-WHILE) + (pos (js2-current-token-beg)) + len body + condition lp + rp))) + "AST node for while-loop." + condition) ; while-condition + +(js2--struct-put 'js2-while-node 'js2-visitor 'js2-visit-while-node) +(js2--struct-put 'js2-while-node 'js2-printer 'js2-print-while-node) + +(defun js2-visit-while-node (n v) + (js2-visit-ast (js2-while-node-condition n) v) + (js2-visit-ast (js2-while-node-body n) v)) + +(defun js2-print-while-node (n i) + (let ((pad (js2-make-pad i))) + (insert pad "while (") + (js2-print-ast (js2-while-node-condition n) 0) + (insert ") {\n") + (js2-print-body (js2-while-node-body n) (1+ i)) + (insert pad "}\n"))) + +(cl-defstruct (js2-for-node + (:include js2-loop-node) + (:constructor make-js2-for-node (&key (type js2-FOR) + (pos js2-ts-cursor) + len body init + condition + update lp rp))) + "AST node for a C-style for-loop." + init ; initialization expression + condition ; loop condition + update) ; update clause + +(js2--struct-put 'js2-for-node 'js2-visitor 'js2-visit-for-node) +(js2--struct-put 'js2-for-node 'js2-printer 'js2-print-for-node) + +(defun js2-visit-for-node (n v) + (js2-visit-ast (js2-for-node-init n) v) + (js2-visit-ast (js2-for-node-condition n) v) + (js2-visit-ast (js2-for-node-update n) v) + (js2-visit-ast (js2-for-node-body n) v)) + +(defun js2-print-for-node (n i) + (let ((pad (js2-make-pad i))) + (insert pad "for (") + (js2-print-ast (js2-for-node-init n) 0) + (insert "; ") + (js2-print-ast (js2-for-node-condition n) 0) + (insert "; ") + (js2-print-ast (js2-for-node-update n) 0) + (insert ") {\n") + (js2-print-body (js2-for-node-body n) (1+ i)) + (insert pad "}\n"))) + +(cl-defstruct (js2-for-in-node + (:include js2-loop-node) + (:constructor make-js2-for-in-node (&key (type js2-FOR) + (pos js2-ts-cursor) + len body + iterator + object + in-pos + each-pos + foreach-p forof-p + lp rp))) + "AST node for a for..in loop." + iterator ; [var] foo in ... + object ; object over which we're iterating + in-pos ; buffer position of 'in' keyword + each-pos ; buffer position of 'each' keyword, if foreach-p + foreach-p ; t if it's a for-each loop + forof-p) ; t if it's a for-of loop + +(js2--struct-put 'js2-for-in-node 'js2-visitor 'js2-visit-for-in-node) +(js2--struct-put 'js2-for-in-node 'js2-printer 'js2-print-for-in-node) + +(defun js2-visit-for-in-node (n v) + (js2-visit-ast (js2-for-in-node-iterator n) v) + (js2-visit-ast (js2-for-in-node-object n) v) + (js2-visit-ast (js2-for-in-node-body n) v)) + +(defun js2-print-for-in-node (n i) + (let ((pad (js2-make-pad i)) + (foreach (js2-for-in-node-foreach-p n)) + (forof (js2-for-in-node-forof-p n))) + (insert pad "for ") + (if foreach + (insert "each ")) + (insert "(") + (js2-print-ast (js2-for-in-node-iterator n) 0) + (insert (if forof " of " " in ")) + (js2-print-ast (js2-for-in-node-object n) 0) + (insert ") {\n") + (js2-print-body (js2-for-in-node-body n) (1+ i)) + (insert pad "}\n"))) + +(cl-defstruct (js2-return-node + (:include js2-node) + (:constructor make-js2-return-node (&key (type js2-RETURN) + (pos js2-ts-cursor) + len + retval))) + "AST node for a return statement." + retval) ; expression to return, or 'undefined + +(js2--struct-put 'js2-return-node 'js2-visitor 'js2-visit-return-node) +(js2--struct-put 'js2-return-node 'js2-printer 'js2-print-return-node) + +(defun js2-visit-return-node (n v) + (js2-visit-ast (js2-return-node-retval n) v)) + +(defun js2-print-return-node (n i) + (insert (js2-make-pad i) "return") + (when (js2-return-node-retval n) + (insert " ") + (js2-print-ast (js2-return-node-retval n) 0)) + (insert ";\n")) + +(cl-defstruct (js2-if-node + (:include js2-node) + (:constructor make-js2-if-node (&key (type js2-IF) + (pos js2-ts-cursor) + len condition + then-part + else-pos + else-part lp + rp))) + "AST node for an if-statement." + condition ; expression + then-part ; statement or block + else-pos ; optional buffer position of 'else' keyword + else-part ; optional statement or block + lp ; position of left-paren, nil if omitted + rp) ; position of right-paren, nil if omitted + +(js2--struct-put 'js2-if-node 'js2-visitor 'js2-visit-if-node) +(js2--struct-put 'js2-if-node 'js2-printer 'js2-print-if-node) + +(defun js2-visit-if-node (n v) + (js2-visit-ast (js2-if-node-condition n) v) + (js2-visit-ast (js2-if-node-then-part n) v) + (js2-visit-ast (js2-if-node-else-part n) v)) + +(defun js2-print-if-node (n i) + (let ((pad (js2-make-pad i)) + (then-part (js2-if-node-then-part n)) + (else-part (js2-if-node-else-part n))) + (insert pad "if (") + (js2-print-ast (js2-if-node-condition n) 0) + (insert ") {\n") + (js2-print-body then-part (1+ i)) + (insert pad "}") + (cond + ((not else-part) + (insert "\n")) + ((js2-if-node-p else-part) + (insert " else ") + (js2-print-body else-part i)) + (t + (insert " else {\n") + (js2-print-body else-part (1+ i)) + (insert pad "}\n"))))) + +(cl-defstruct (js2-export-binding-node + (:include js2-node) + (:constructor make-js2-export-binding-node (&key (type -1) + pos + len + local-name + extern-name))) + "AST node for an external symbol binding. +It contains a local-name node which is the name of the value in the +current scope, and extern-name which is the name of the value in the +imported or exported scope. By default these are the same, but if the +name is aliased as in {foo as bar}, it would have an extern-name node +containing `foo' and a local-name node containing `bar'." + local-name ; js2-name-node with the variable name in this scope + extern-name) ; js2-name-node with the value name in the exporting module + +(js2--struct-put 'js2-export-binding-node 'js2-printer 'js2-print-extern-binding) +(js2--struct-put 'js2-export-binding-node 'js2-visitor 'js2-visit-extern-binding) + +(defun js2-visit-extern-binding (n v) + "Visit an extern binding node. First visit the local-name, and, if +different, visit the extern-name." + (let ((local-name (js2-export-binding-node-local-name n)) + (extern-name (js2-export-binding-node-extern-name n))) + (when local-name + (js2-visit-ast local-name v)) + (when (not (equal local-name extern-name)) + (js2-visit-ast extern-name v)))) + +(defun js2-print-extern-binding (n _i) + "Print a representation of a single extern binding. E.g. `foo' or +`foo as bar'." + (let ((local-name (js2-export-binding-node-local-name n)) + (extern-name (js2-export-binding-node-extern-name n))) + (insert (js2-name-node-name extern-name)) + (when (not (equal local-name extern-name)) + (insert " as ") + (insert (js2-name-node-name local-name))))) + + +(cl-defstruct (js2-import-node + (:include js2-node) + (:constructor make-js2-import-node (&key (type js2-IMPORT) + (pos (js2-current-token-beg)) + len + import + from + module-id))) + "AST node for an import statement. It follows the form + +import ModuleSpecifier; +import ImportClause FromClause;" + import ; js2-import-clause-node specifying which names are to imported. + from ; js2-from-clause-node indicating the module from which to import. + module-id) ; module-id of the import. E.g. 'src/mylib'. + +(js2--struct-put 'js2-import-node 'js2-printer 'js2-print-import) +(js2--struct-put 'js2-import-node 'js2-visitor 'js2-visit-import) + +(defun js2-visit-import (n v) + (let ((import-clause (js2-import-node-import n)) + (from-clause (js2-import-node-from n))) + (when import-clause + (js2-visit-ast import-clause v)) + (when from-clause + (js2-visit-ast from-clause v)))) + +(defun js2-print-import (n i) + "Prints a representation of the import node" + (let ((pad (js2-make-pad i)) + (import-clause (js2-import-node-import n)) + (from-clause (js2-import-node-from n)) + (module-id (js2-import-node-module-id n))) + (insert pad "import ") + (if import-clause + (progn + (js2-print-import-clause import-clause) + (insert " ") + (js2-print-from-clause from-clause)) + (insert "'") + (insert module-id) + (insert "'")) + (insert ";\n"))) + +(cl-defstruct (js2-import-clause-node + (:include js2-node) + (:constructor make-js2-import-clause-node (&key (type -1) + pos + len + namespace-import + named-imports + default-binding))) + "AST node corresponding to the import clause of an import statement. This is +the portion of the import that bindings names from the external context to the +local context." + namespace-import ; js2-namespace-import-node. E.g. '* as lib' + named-imports ; lisp list of js2-export-binding-node for all named imports. + default-binding) ; js2-export-binding-node for the default import binding + +(js2--struct-put 'js2-import-clause-node 'js2-visitor 'js2-visit-import-clause) +(js2--struct-put 'js2-import-clause-node 'js2-printer 'js2-print-import-clause) + +(defun js2-visit-import-clause (n v) + (let ((ns-import (js2-import-clause-node-namespace-import n)) + (named-imports (js2-import-clause-node-named-imports n)) + (default (js2-import-clause-node-default-binding n))) + (when default + (js2-visit-ast default v)) + (when ns-import + (js2-visit-ast ns-import v)) + (when named-imports + (dolist (import named-imports) + (js2-visit-ast import v))))) + +(defun js2-print-import-clause (n) + (let ((ns-import (js2-import-clause-node-namespace-import n)) + (named-imports (js2-import-clause-node-named-imports n)) + (default (js2-import-clause-node-default-binding n))) + (cond + ((and default ns-import) + (js2-print-ast default) + (insert ", ") + (js2-print-namespace-import ns-import)) + ((and default named-imports) + (js2-print-ast default) + (insert ", ") + (js2-print-named-imports named-imports)) + (default + (js2-print-ast default)) + (ns-import + (js2-print-namespace-import ns-import)) + (named-imports + (js2-print-named-imports named-imports))))) + +(defun js2-print-namespace-import (node) + (insert "* as ") + (insert (js2-name-node-name (js2-namespace-import-node-name node)))) + +(defun js2-print-named-imports (imports) + (insert "{") + (let ((len (length imports)) + (n 0)) + (while (< n len) + (js2-print-extern-binding (nth n imports) 0) + (unless (= n (- len 1)) + (insert ", ")) + (setq n (+ n 1)))) + (insert "}")) + +(cl-defstruct (js2-namespace-import-node + (:include js2-node) + (:constructor make-js2-namespace-import-node (&key (type -1) + pos + len + name))) + "AST node for a complete namespace import. +E.g. the `* as lib' expression in: + +import * as lib from \\='src/lib\\=' + +It contains a single name node referring to the bound name." + name) ; js2-name-node of the bound name. + +(defun js2-visit-namespace-import (n v) + (js2-visit-ast (js2-namespace-import-node-name n) v)) + +(js2--struct-put 'js2-namespace-import-node 'js2-visitor 'js2-visit-namespace-import) +(js2--struct-put 'js2-namespace-import-node 'js2-printer 'js2-print-namespace-import) + +(cl-defstruct (js2-from-clause-node + (:include js2-node) + (:constructor make-js2-from-clause-node (&key (type js2-NAME) + pos + len + module-id + metadata-p))) + "AST node for the from clause in an import or export statement. +E.g. from \\='my/module\\='. It can refere to either an external module, or to the +modules metadata itself." + module-id ; string containing the module specifier. + metadata-p) ; true if this clause refers to the module's metadata + +(js2--struct-put 'js2-from-clause-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-from-clause-node 'js2-printer 'js2-print-from-clause) + +(defun js2-print-from-clause (n) + (insert "from ") + (if (js2-from-clause-node-metadata-p n) + (insert "this module") + (insert "'") + (insert (js2-from-clause-node-module-id n)) + (insert "'"))) + +(cl-defstruct (js2-try-node + (:include js2-node) + (:constructor make-js2-try-node (&key (type js2-TRY) + (pos js2-ts-cursor) + len + try-block + catch-clauses + finally-block))) + "AST node for a try-statement." + try-block + catch-clauses ; a Lisp list of `js2-catch-node' + finally-block) ; a `js2-finally-node' + +(js2--struct-put 'js2-try-node 'js2-visitor 'js2-visit-try-node) +(js2--struct-put 'js2-try-node 'js2-printer 'js2-print-try-node) + +(defun js2-visit-try-node (n v) + (js2-visit-ast (js2-try-node-try-block n) v) + (dolist (clause (js2-try-node-catch-clauses n)) + (js2-visit-ast clause v)) + (js2-visit-ast (js2-try-node-finally-block n) v)) + +(defun js2-print-try-node (n i) + (let ((pad (js2-make-pad i)) + (catches (js2-try-node-catch-clauses n)) + (finally (js2-try-node-finally-block n))) + (insert pad "try {\n") + (js2-print-body (js2-try-node-try-block n) (1+ i)) + (insert pad "}") + (when catches + (dolist (catch catches) + (js2-print-ast catch i))) + (if finally + (js2-print-ast finally i) + (insert "\n")))) + +(cl-defstruct (js2-catch-node + (:include js2-scope) + (:constructor make-js2-catch-node (&key (type js2-CATCH) + (pos js2-ts-cursor) + len + param + guard-kwd + guard-expr + lp rp))) + "AST node for a catch clause." + param ; destructuring form or simple name node + guard-kwd ; relative buffer position of "if" in "catch (x if ...)" + guard-expr ; catch condition, a `js2-node' + lp ; buffer position of left-paren, nil if omitted + rp) ; buffer position of right-paren, nil if omitted + +(js2--struct-put 'js2-catch-node 'js2-visitor 'js2-visit-catch-node) +(js2--struct-put 'js2-catch-node 'js2-printer 'js2-print-catch-node) + +(defun js2-visit-catch-node (n v) + (js2-visit-ast (js2-catch-node-param n) v) + (when (js2-catch-node-guard-kwd n) + (js2-visit-ast (js2-catch-node-guard-expr n) v)) + (js2-visit-block n v)) + +(defun js2-print-catch-node (n i) + (let ((pad (js2-make-pad i)) + (guard-kwd (js2-catch-node-guard-kwd n)) + (guard-expr (js2-catch-node-guard-expr n))) + (insert " catch (") + (js2-print-ast (js2-catch-node-param n) 0) + (when guard-kwd + (insert " if ") + (js2-print-ast guard-expr 0)) + (insert ") {\n") + (js2-print-body n (1+ i)) + (insert pad "}"))) + +(cl-defstruct (js2-finally-node + (:include js2-node) + (:constructor make-js2-finally-node (&key (type js2-FINALLY) + (pos js2-ts-cursor) + len body))) + "AST node for a finally clause." + body) ; a `js2-node', often but not always a block node + +(js2--struct-put 'js2-finally-node 'js2-visitor 'js2-visit-finally-node) +(js2--struct-put 'js2-finally-node 'js2-printer 'js2-print-finally-node) + +(defun js2-visit-finally-node (n v) + (js2-visit-ast (js2-finally-node-body n) v)) + +(defun js2-print-finally-node (n i) + (let ((pad (js2-make-pad i))) + (insert " finally {\n") + (js2-print-body (js2-finally-node-body n) (1+ i)) + (insert pad "}\n"))) + +(cl-defstruct (js2-switch-node + (:include js2-scope) + (:constructor make-js2-switch-node (&key (type js2-SWITCH) + (pos js2-ts-cursor) + len + discriminant + cases lp + rp))) + "AST node for a switch statement." + discriminant ; a `js2-node' (switch expression) + cases ; a Lisp list of `js2-case-node' + lp ; position of open-paren for discriminant, nil if omitted + rp) ; position of close-paren for discriminant, nil if omitted + +(js2--struct-put 'js2-switch-node 'js2-visitor 'js2-visit-switch-node) +(js2--struct-put 'js2-switch-node 'js2-printer 'js2-print-switch-node) + +(defun js2-visit-switch-node (n v) + (js2-visit-ast (js2-switch-node-discriminant n) v) + (dolist (c (js2-switch-node-cases n)) + (js2-visit-ast c v))) + +(defun js2-print-switch-node (n i) + (let ((pad (js2-make-pad i)) + (cases (js2-switch-node-cases n))) + (insert pad "switch (") + (js2-print-ast (js2-switch-node-discriminant n) 0) + (insert ") {\n") + (dolist (case cases) + (js2-print-ast case i)) + (insert pad "}\n"))) + +(cl-defstruct (js2-case-node + (:include js2-block-node) + (:constructor make-js2-case-node (&key (type js2-CASE) + (pos js2-ts-cursor) + len kids expr))) + "AST node for a case clause of a switch statement." + expr) ; the case expression (nil for default) + +(js2--struct-put 'js2-case-node 'js2-visitor 'js2-visit-case-node) +(js2--struct-put 'js2-case-node 'js2-printer 'js2-print-case-node) + +(defun js2-visit-case-node (n v) + (js2-visit-ast (js2-case-node-expr n) v) + (js2-visit-block n v)) + +(defun js2-print-case-node (n i) + (let ((pad (js2-make-pad i)) + (expr (js2-case-node-expr n))) + (insert pad) + (if (null expr) + (insert "default:\n") + (insert "case ") + (js2-print-ast expr 0) + (insert ":\n")) + (dolist (kid (js2-case-node-kids n)) + (js2-print-ast kid (1+ i))))) + +(cl-defstruct (js2-throw-node + (:include js2-node) + (:constructor make-js2-throw-node (&key (type js2-THROW) + (pos js2-ts-cursor) + len expr))) + "AST node for a throw statement." + expr) ; the expression to throw + +(js2--struct-put 'js2-throw-node 'js2-visitor 'js2-visit-throw-node) +(js2--struct-put 'js2-throw-node 'js2-printer 'js2-print-throw-node) + +(defun js2-visit-throw-node (n v) + (js2-visit-ast (js2-throw-node-expr n) v)) + +(defun js2-print-throw-node (n i) + (insert (js2-make-pad i) "throw ") + (js2-print-ast (js2-throw-node-expr n) 0) + (insert ";\n")) + +(cl-defstruct (js2-with-node + (:include js2-node) + (:constructor make-js2-with-node (&key (type js2-WITH) + (pos js2-ts-cursor) + len object + body lp rp))) + "AST node for a with-statement." + object + body + lp ; buffer position of left-paren around object, nil if omitted + rp) ; buffer position of right-paren around object, nil if omitted + +(js2--struct-put 'js2-with-node 'js2-visitor 'js2-visit-with-node) +(js2--struct-put 'js2-with-node 'js2-printer 'js2-print-with-node) + +(defun js2-visit-with-node (n v) + (js2-visit-ast (js2-with-node-object n) v) + (js2-visit-ast (js2-with-node-body n) v)) + +(defun js2-print-with-node (n i) + (let ((pad (js2-make-pad i))) + (insert pad "with (") + (js2-print-ast (js2-with-node-object n) 0) + (insert ") {\n") + (js2-print-body (js2-with-node-body n) (1+ i)) + (insert pad "}\n"))) + +(cl-defstruct (js2-label-node + (:include js2-node) + (:constructor make-js2-label-node (&key (type js2-LABEL) + (pos js2-ts-cursor) + len name))) + "AST node for a statement label or case label." + name ; a string + loop) ; for validating and code-generating continue-to-label + +(js2--struct-put 'js2-label-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-label-node 'js2-printer 'js2-print-label) + +(defun js2-print-label (n i) + (insert (js2-make-pad i) + (js2-label-node-name n) + ":\n")) + +(cl-defstruct (js2-labeled-stmt-node + (:include js2-node) + ;; type needs to be in `js2-side-effecting-tokens' to avoid spurious + ;; no-side-effects warnings, hence js2-EXPR_RESULT. + (:constructor make-js2-labeled-stmt-node (&key (type js2-EXPR_RESULT) + (pos js2-ts-cursor) + len labels stmt))) + "AST node for a statement with one or more labels. +Multiple labels for a statement are collapsed into the labels field." + labels ; Lisp list of `js2-label-node' + stmt) ; the statement these labels are for + +(js2--struct-put 'js2-labeled-stmt-node 'js2-visitor 'js2-visit-labeled-stmt) +(js2--struct-put 'js2-labeled-stmt-node 'js2-printer 'js2-print-labeled-stmt) + +(defun js2-get-label-by-name (lbl-stmt name) + "Return a `js2-label-node' by NAME from LBL-STMT's labels list. +Returns nil if no such label is in the list." + (let ((label-list (js2-labeled-stmt-node-labels lbl-stmt)) + result) + (while (and label-list (not result)) + (if (string= (js2-label-node-name (car label-list)) name) + (setq result (car label-list)) + (setq label-list (cdr label-list)))) + result)) + +(defun js2-visit-labeled-stmt (n v) + (dolist (label (js2-labeled-stmt-node-labels n)) + (js2-visit-ast label v)) + (js2-visit-ast (js2-labeled-stmt-node-stmt n) v)) + +(defun js2-print-labeled-stmt (n i) + (dolist (label (js2-labeled-stmt-node-labels n)) + (js2-print-ast label i)) + (js2-print-ast (js2-labeled-stmt-node-stmt n) i)) + +(defun js2-labeled-stmt-node-contains (node label) + "Return t if NODE contains LABEL in its label set. +NODE is a `js2-labels-node'. LABEL is an identifier." + (cl-loop for nl in (js2-labeled-stmt-node-labels node) + if (string= label (js2-label-node-name nl)) + return t + finally return nil)) + +(defsubst js2-labeled-stmt-node-add-label (node label) + "Add a `js2-label-node' to the label set for this statement." + (setf (js2-labeled-stmt-node-labels node) + (nconc (js2-labeled-stmt-node-labels node) (list label)))) + +(cl-defstruct (js2-jump-node + (:include js2-node) + (:constructor nil)) + "Abstract supertype of break and continue nodes." + label ; `js2-name-node' for location of label identifier, if present + target) ; target js2-labels-node or loop/switch statement + +(defun js2-visit-jump-node (n v) + ;; We don't visit the target, since it's a back-link. + (js2-visit-ast (js2-jump-node-label n) v)) + +(cl-defstruct (js2-break-node + (:include js2-jump-node) + (:constructor make-js2-break-node (&key (type js2-BREAK) + (pos js2-ts-cursor) + len label target))) + "AST node for a break statement. +The label field is a `js2-name-node', possibly nil, for the named label +if provided. E.g. in `break foo', it represents `foo'. The target field +is the target of the break - a label node or enclosing loop/switch statement.") + +(js2--struct-put 'js2-break-node 'js2-visitor 'js2-visit-jump-node) +(js2--struct-put 'js2-break-node 'js2-printer 'js2-print-break-node) + +(defun js2-print-break-node (n i) + (insert (js2-make-pad i) "break") + (when (js2-break-node-label n) + (insert " ") + (js2-print-ast (js2-break-node-label n) 0)) + (insert ";\n")) + +(cl-defstruct (js2-continue-node + (:include js2-jump-node) + (:constructor make-js2-continue-node (&key (type js2-CONTINUE) + (pos js2-ts-cursor) + len label target))) + "AST node for a continue statement. +The label field is the user-supplied enclosing label name, a `js2-name-node'. +It is nil if continue specifies no label. The target field is the jump target: +a `js2-label-node' or the innermost enclosing loop.") + +(js2--struct-put 'js2-continue-node 'js2-visitor 'js2-visit-jump-node) +(js2--struct-put 'js2-continue-node 'js2-printer 'js2-print-continue-node) + +(defun js2-print-continue-node (n i) + (insert (js2-make-pad i) "continue") + (when (js2-continue-node-label n) + (insert " ") + (js2-print-ast (js2-continue-node-label n) 0)) + (insert ";\n")) + +(cl-defstruct (js2-function-node + (:include js2-script-node) + (:constructor make-js2-function-node (&key (type js2-FUNCTION) + (pos js2-ts-cursor) + len + (ftype 'FUNCTION) + (form 'FUNCTION_STATEMENT) + (name "") + params rest-p + body + generator-type + async + lp rp))) + "AST node for a function declaration. +The `params' field is a Lisp list of nodes. Each node is either a simple +`js2-name-node', or if it's a destructuring-assignment parameter, a +`js2-array-node' or `js2-object-node'." + ftype ; FUNCTION, GETTER or SETTER + form ; FUNCTION_{STATEMENT|EXPRESSION|ARROW} + name ; function name (a `js2-name-node', or nil if anonymous) + params ; a Lisp list of destructuring forms or simple name nodes + rest-p ; if t, the last parameter is rest parameter + body ; a `js2-block-node' or expression node (1.8 only) + lp ; position of arg-list open-paren, or nil if omitted + rp ; position of arg-list close-paren, or nil if omitted + ignore-dynamic ; ignore value of the dynamic-scope flag (interpreter only) + needs-activation ; t if we need an activation object for this frame + generator-type ; STAR, LEGACY, COMPREHENSION or nil + async ; t if the function is defined as `async function` + member-expr) ; nonstandard Ecma extension from Rhino + +(js2--struct-put 'js2-function-node 'js2-visitor 'js2-visit-function-node) +(js2--struct-put 'js2-function-node 'js2-printer 'js2-print-function-node) + +(defun js2-visit-function-node (n v) + (js2-visit-ast (js2-function-node-name n) v) + (dolist (p (js2-function-node-params n)) + (js2-visit-ast p v)) + (js2-visit-ast (js2-function-node-body n) v)) + +(defun js2-print-function-node (n i) + (let* ((pad (js2-make-pad i)) + (method (js2-node-get-prop n 'METHOD_TYPE)) + (name (or (js2-function-node-name n) + (js2-function-node-member-expr n))) + (params (js2-function-node-params n)) + (arrow (eq (js2-function-node-form n) 'FUNCTION_ARROW)) + (rest-p (js2-function-node-rest-p n)) + (body (js2-function-node-body n)) + (expr (not (eq (js2-function-node-form n) 'FUNCTION_STATEMENT)))) + (unless method + (insert pad) + (when (js2-function-node-async n) (insert "async ")) + (unless arrow (insert "function")) + (when (eq (js2-function-node-generator-type n) 'STAR) + (insert "*"))) + (when name + (insert " ") + (js2-print-ast name 0)) + (insert "(") + (cl-loop with len = (length params) + for param in params + for count from 1 + do + (when (and rest-p (= count len)) + (insert "...")) + (js2-print-ast param 0) + (when (< count len) + (insert ", "))) + (insert ") ") + (when arrow + (insert "=> ")) + (insert "{") + ;; TODO: fix this to be smarter about indenting, etc. + (unless expr + (insert "\n")) + (if (js2-block-node-p body) + (js2-print-body body (1+ i)) + (js2-print-ast body 0)) + (insert pad "}") + (unless expr + (insert "\n")))) + +(defun js2-function-name (node) + "Return function name for NODE, a `js2-function-node', or nil if anonymous." + (and (js2-function-node-name node) + (js2-name-node-name (js2-function-node-name node)))) + +;; Having this be an expression node makes it more flexible. +;; There are IDE contexts, such as indentation in a for-loop initializer, +;; that work better if you assume it's an expression. Whenever we have +;; a standalone var/const declaration, we just wrap with an expr stmt. +;; Eclipse apparently screwed this up and now has two versions, expr and stmt. +(cl-defstruct (js2-var-decl-node + (:include js2-node) + (:constructor make-js2-var-decl-node (&key (type js2-VAR) + (pos (js2-current-token-beg)) + len kids + decl-type))) + "AST node for a variable declaration list (VAR, CONST or LET). +The node bounds differ depending on the declaration type. For VAR or +CONST declarations, the bounds include the var/const keyword. For LET +declarations, the node begins at the position of the first child." + kids ; a Lisp list of `js2-var-init-node' structs. + decl-type) ; js2-VAR, js2-CONST or js2-LET + +(js2--struct-put 'js2-var-decl-node 'js2-visitor 'js2-visit-var-decl) +(js2--struct-put 'js2-var-decl-node 'js2-printer 'js2-print-var-decl) + +(defun js2-visit-var-decl (n v) + (dolist (kid (js2-var-decl-node-kids n)) + (js2-visit-ast kid v))) + +(defun js2-print-var-decl (n i) + (let ((pad (js2-make-pad i)) + (tt (js2-var-decl-node-decl-type n))) + (insert pad) + (insert (cond + ((= tt js2-VAR) "var ") + ((= tt js2-LET) "let ") + ((= tt js2-CONST) "const ") + (t + (error "malformed var-decl node")))) + (cl-loop with kids = (js2-var-decl-node-kids n) + with len = (length kids) + for kid in kids + for count from 1 + do + (js2-print-ast kid 0) + (if (< count len) + (insert ", "))))) + +(cl-defstruct (js2-var-init-node + (:include js2-node) + (:constructor make-js2-var-init-node (&key (type js2-VAR) + (pos js2-ts-cursor) + len target + initializer))) + "AST node for a variable declaration. +The type field will be js2-CONST for a const decl." + target ; `js2-name-node', `js2-object-node', or `js2-array-node' + initializer) ; initializer expression, a `js2-node' + +(js2--struct-put 'js2-var-init-node 'js2-visitor 'js2-visit-var-init-node) +(js2--struct-put 'js2-var-init-node 'js2-printer 'js2-print-var-init-node) + +(defun js2-visit-var-init-node (n v) + (js2-visit-ast (js2-var-init-node-target n) v) + (js2-visit-ast (js2-var-init-node-initializer n) v)) + +(defun js2-print-var-init-node (n i) + (let ((pad (js2-make-pad i)) + (name (js2-var-init-node-target n)) + (init (js2-var-init-node-initializer n))) + (insert pad) + (js2-print-ast name 0) + (when init + (insert " = ") + (js2-print-ast init 0)))) + +(cl-defstruct (js2-cond-node + (:include js2-node) + (:constructor make-js2-cond-node (&key (type js2-HOOK) + (pos js2-ts-cursor) + len + test-expr + true-expr + false-expr + q-pos c-pos))) + "AST node for the ternary operator" + test-expr + true-expr + false-expr + q-pos ; buffer position of ? + c-pos) ; buffer position of : + +(js2--struct-put 'js2-cond-node 'js2-visitor 'js2-visit-cond-node) +(js2--struct-put 'js2-cond-node 'js2-printer 'js2-print-cond-node) + +(defun js2-visit-cond-node (n v) + (js2-visit-ast (js2-cond-node-test-expr n) v) + (js2-visit-ast (js2-cond-node-true-expr n) v) + (js2-visit-ast (js2-cond-node-false-expr n) v)) + +(defun js2-print-cond-node (n i) + (let ((pad (js2-make-pad i))) + (insert pad) + (js2-print-ast (js2-cond-node-test-expr n) 0) + (insert " ? ") + (js2-print-ast (js2-cond-node-true-expr n) 0) + (insert " : ") + (js2-print-ast (js2-cond-node-false-expr n) 0))) + +(cl-defstruct (js2-infix-node + (:include js2-node) + (:constructor make-js2-infix-node (&key type + (pos js2-ts-cursor) + len op-pos + left right))) + "Represents infix expressions. +Includes assignment ops like `|=', and the comma operator. +The type field inherited from `js2-node' holds the operator." + op-pos ; buffer position where operator begins + left ; any `js2-node' + right) ; any `js2-node' + +(js2--struct-put 'js2-infix-node 'js2-visitor 'js2-visit-infix-node) +(js2--struct-put 'js2-infix-node 'js2-printer 'js2-print-infix-node) + +(defun js2-visit-infix-node (n v) + (js2-visit-ast (js2-infix-node-left n) v) + (js2-visit-ast (js2-infix-node-right n) v)) + +(defconst js2-operator-tokens + (let ((table (make-hash-table :test 'eq)) + (tokens + (list (cons js2-IN "in") + (cons js2-TYPEOF "typeof") + (cons js2-INSTANCEOF "instanceof") + (cons js2-DELPROP "delete") + (cons js2-AWAIT "await") + (cons js2-VOID "void") + (cons js2-COMMA ",") + (cons js2-COLON ":") + (cons js2-OR "||") + (cons js2-AND "&&") + (cons js2-INC "++") + (cons js2-DEC "--") + (cons js2-BITOR "|") + (cons js2-BITXOR "^") + (cons js2-BITAND "&") + (cons js2-EQ "==") + (cons js2-NE "!=") + (cons js2-LT "<") + (cons js2-LE "<=") + (cons js2-GT ">") + (cons js2-GE ">=") + (cons js2-LSH "<<") + (cons js2-RSH ">>") + (cons js2-URSH ">>>") + (cons js2-ADD "+") ; infix plus + (cons js2-SUB "-") ; infix minus + (cons js2-MUL "*") + (cons js2-EXPON "**") + (cons js2-DIV "/") + (cons js2-MOD "%") + (cons js2-NOT "!") + (cons js2-BITNOT "~") + (cons js2-POS "+") ; unary plus + (cons js2-NEG "-") ; unary minus + (cons js2-TRIPLEDOT "...") + (cons js2-SHEQ "===") ; shallow equality + (cons js2-SHNE "!==") ; shallow inequality + (cons js2-ASSIGN "=") + (cons js2-ASSIGN_BITOR "|=") + (cons js2-ASSIGN_BITXOR "^=") + (cons js2-ASSIGN_BITAND "&=") + (cons js2-ASSIGN_LSH "<<=") + (cons js2-ASSIGN_RSH ">>=") + (cons js2-ASSIGN_URSH ">>>=") + (cons js2-ASSIGN_ADD "+=") + (cons js2-ASSIGN_SUB "-=") + (cons js2-ASSIGN_MUL "*=") + (cons js2-ASSIGN_EXPON "**=") + (cons js2-ASSIGN_DIV "/=") + (cons js2-ASSIGN_MOD "%=")))) + (cl-loop for (k . v) in tokens do + (puthash k v table)) + table)) + +(defun js2-print-infix-node (n i) + (let* ((tt (js2-node-type n)) + (op (gethash tt js2-operator-tokens))) + (unless op + (error "unrecognized infix operator %s" (js2-node-type n))) + (insert (js2-make-pad i)) + (js2-print-ast (js2-infix-node-left n) 0) + (unless (= tt js2-COMMA) + (insert " ")) + (insert op) + (insert " ") + (js2-print-ast (js2-infix-node-right n) 0))) + +(cl-defstruct (js2-assign-node + (:include js2-infix-node) + (:constructor make-js2-assign-node (&key type + (pos js2-ts-cursor) + len op-pos + left right))) + "Represents any assignment. +The type field holds the actual assignment operator.") + +(js2--struct-put 'js2-assign-node 'js2-visitor 'js2-visit-infix-node) +(js2--struct-put 'js2-assign-node 'js2-printer 'js2-print-infix-node) + +(cl-defstruct (js2-unary-node + (:include js2-node) + (:constructor make-js2-unary-node (&key type ; required + (pos js2-ts-cursor) + len operand))) + "AST node type for unary operator nodes. +The type field can be NOT, BITNOT, POS, NEG, INC, DEC, +TYPEOF, DELPROP, TRIPLEDOT or AWAIT. For INC or DEC, a 'postfix node +property is added if the operator follows the operand." + operand) ; a `js2-node' expression + +(js2--struct-put 'js2-unary-node 'js2-visitor 'js2-visit-unary-node) +(js2--struct-put 'js2-unary-node 'js2-printer 'js2-print-unary-node) + +(defun js2-visit-unary-node (n v) + (js2-visit-ast (js2-unary-node-operand n) v)) + +(defun js2-print-unary-node (n i) + (let* ((tt (js2-node-type n)) + (op (gethash tt js2-operator-tokens)) + (postfix (js2-node-get-prop n 'postfix))) + (unless op + (error "unrecognized unary operator %s" tt)) + (insert (js2-make-pad i)) + (unless postfix + (insert op)) + (if (or (= tt js2-TYPEOF) + (= tt js2-DELPROP) + (= tt js2-AWAIT) + (= tt js2-VOID)) + (insert " ")) + (js2-print-ast (js2-unary-node-operand n) 0) + (when postfix + (insert op)))) + +(cl-defstruct (js2-let-node + (:include js2-scope) + (:constructor make-js2-let-node (&key (type js2-LETEXPR) + (pos (js2-current-token-beg)) + len vars body + lp rp))) + "AST node for a let expression or a let statement. +Note that a let declaration such as let x=6, y=7 is a `js2-var-decl-node'." + vars ; a `js2-var-decl-node' + body ; a `js2-node' representing the expression or body block + lp + rp) + +(js2--struct-put 'js2-let-node 'js2-visitor 'js2-visit-let-node) +(js2--struct-put 'js2-let-node 'js2-printer 'js2-print-let-node) + +(defun js2-visit-let-node (n v) + (js2-visit-ast (js2-let-node-vars n) v) + (js2-visit-ast (js2-let-node-body n) v)) + +(defun js2-print-let-node (n i) + (insert (js2-make-pad i) "let (") + (let ((p (point))) + (js2-print-ast (js2-let-node-vars n) 0) + (delete-region p (+ p 4))) + (insert ") ") + (js2-print-ast (js2-let-node-body n) i)) + +(cl-defstruct (js2-keyword-node + (:include js2-node) + (:constructor make-js2-keyword-node (&key type + (pos (js2-current-token-beg)) + (len (- js2-ts-cursor pos))))) + "AST node representing a literal keyword such as `null'. +Used for `null', `this', `true', `false' and `debugger'. +The node type is set to js2-NULL, js2-THIS, etc.") + +(js2--struct-put 'js2-keyword-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-keyword-node 'js2-printer 'js2-print-keyword-node) + +(defun js2-print-keyword-node (n i) + (insert (js2-make-pad i) + (let ((tt (js2-node-type n))) + (cond + ((= tt js2-THIS) "this") + ((= tt js2-SUPER) "super") + ((= tt js2-NULL) "null") + ((= tt js2-TRUE) "true") + ((= tt js2-FALSE) "false") + ((= tt js2-DEBUGGER) "debugger") + (t (error "Invalid keyword literal type: %d" tt)))))) + +(defsubst js2-this-or-super-node-p (node) + "Return t if NODE is a `js2-literal-node' of type js2-THIS or js2-SUPER." + (let ((type (js2-node-type node))) + (or (eq type js2-THIS) (eq type js2-SUPER)))) + +(cl-defstruct (js2-new-node + (:include js2-node) + (:constructor make-js2-new-node (&key (type js2-NEW) + (pos (js2-current-token-beg)) + len target + args initializer + lp rp))) + "AST node for new-expression such as new Foo()." + target ; an identifier or reference + args ; a Lisp list of argument nodes + lp ; position of left-paren, nil if omitted + rp ; position of right-paren, nil if omitted + initializer) ; experimental Rhino syntax: optional `js2-object-node' + +(js2--struct-put 'js2-new-node 'js2-visitor 'js2-visit-new-node) +(js2--struct-put 'js2-new-node 'js2-printer 'js2-print-new-node) + +(defun js2-visit-new-node (n v) + (js2-visit-ast (js2-new-node-target n) v) + (dolist (arg (js2-new-node-args n)) + (js2-visit-ast arg v)) + (js2-visit-ast (js2-new-node-initializer n) v)) + +(defun js2-print-new-node (n i) + (insert (js2-make-pad i) "new ") + (js2-print-ast (js2-new-node-target n)) + (insert "(") + (js2-print-list (js2-new-node-args n)) + (insert ")") + (when (js2-new-node-initializer n) + (insert " ") + (js2-print-ast (js2-new-node-initializer n)))) + +(cl-defstruct (js2-name-node + (:include js2-node) + (:constructor make-js2-name-node (&key (type js2-NAME) + (pos (js2-current-token-beg)) + (len (- js2-ts-cursor + (js2-current-token-beg))) + (name (js2-current-token-string))))) + "AST node for a JavaScript identifier" + name ; a string + scope) ; a `js2-scope' (optional, used for codegen) + +(js2--struct-put 'js2-name-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-name-node 'js2-printer 'js2-print-name-node) + +(defun js2-print-name-node (n i) + (insert (js2-make-pad i) + (js2-name-node-name n))) + +(defsubst js2-name-node-length (node) + "Return identifier length of NODE, a `js2-name-node'. +Returns 0 if NODE is nil or its identifier field is nil." + (if node + (length (js2-name-node-name node)) + 0)) + +(cl-defstruct (js2-number-node + (:include js2-node) + (:constructor make-js2-number-node (&key (type js2-NUMBER) + (pos (js2-current-token-beg)) + (len (- js2-ts-cursor + (js2-current-token-beg))) + (value (js2-current-token-string)) + (num-value (js2-token-number + (js2-current-token))) + (num-base (js2-token-number-base + (js2-current-token))) + (legacy-octal-p (js2-token-number-legacy-octal-p + (js2-current-token)))))) + "AST node for a number literal." + value ; the original string, e.g. "6.02e23" + num-value ; the parsed number value + num-base ; the number's base + legacy-octal-p) ; whether the number is a legacy octal (0123 instead of 0o123) + +(js2--struct-put 'js2-number-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-number-node 'js2-printer 'js2-print-number-node) + +(defun js2-print-number-node (n i) + (insert (js2-make-pad i) + (number-to-string (js2-number-node-num-value n)))) + +(cl-defstruct (js2-regexp-node + (:include js2-node) + (:constructor make-js2-regexp-node (&key (type js2-REGEXP) + (pos (js2-current-token-beg)) + (len (- js2-ts-cursor + (js2-current-token-beg))) + value flags))) + "AST node for a regular expression literal." + value ; the regexp string, without // delimiters + flags) ; a string of flags, e.g. `mi'. + +(js2--struct-put 'js2-regexp-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-regexp-node 'js2-printer 'js2-print-regexp) + +(defun js2-print-regexp (n i) + (insert (js2-make-pad i) + "/" + (js2-regexp-node-value n) + "/") + (if (js2-regexp-node-flags n) + (insert (js2-regexp-node-flags n)))) + +(cl-defstruct (js2-string-node + (:include js2-node) + (:constructor make-js2-string-node (&key (type js2-STRING) + (pos (js2-current-token-beg)) + (len (- js2-ts-cursor + (js2-current-token-beg))) + (value (js2-current-token-string))))) + "String literal. +Escape characters are not evaluated; e.g. \n is 2 chars in value field. +You can tell the quote type by looking at the first character." + value) ; the characters of the string, including the quotes + +(js2--struct-put 'js2-string-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-string-node 'js2-printer 'js2-print-string-node) + +(defun js2-print-string-node (n i) + (insert (js2-make-pad i) + (js2-node-string n))) + +(cl-defstruct (js2-template-node + (:include js2-node) + (:constructor make-js2-template-node (&key (type js2-TEMPLATE_HEAD) + pos len kids))) + "Template literal." + kids) ; `js2-string-node' is used for string segments, other nodes + ; for substitutions inside. + +(js2--struct-put 'js2-template-node 'js2-visitor 'js2-visit-template) +(js2--struct-put 'js2-template-node 'js2-printer 'js2-print-template) + +(defun js2-visit-template (n callback) + (dolist (kid (js2-template-node-kids n)) + (js2-visit-ast kid callback))) + +(defun js2-print-template (n i) + (insert (js2-make-pad i)) + (dolist (kid (js2-template-node-kids n)) + (if (js2-string-node-p kid) + (insert (js2-node-string kid)) + (js2-print-ast kid)))) + +(cl-defstruct (js2-tagged-template-node + (:include js2-node) + (:constructor make-js2-tagged-template-node (&key (type js2-TAGGED_TEMPLATE) + pos len tag template))) + "Tagged template literal." + tag ; `js2-node' with the tag expression. + template) ; `js2-template-node' with the template. + +(js2--struct-put 'js2-tagged-template-node 'js2-visitor 'js2-visit-tagged-template) +(js2--struct-put 'js2-tagged-template-node 'js2-printer 'js2-print-tagged-template) + +(defun js2-visit-tagged-template (n callback) + (js2-visit-ast (js2-tagged-template-node-tag n) callback) + (js2-visit-ast (js2-tagged-template-node-template n) callback)) + +(defun js2-print-tagged-template (n i) + (insert (js2-make-pad i)) + (js2-print-ast (js2-tagged-template-node-tag n)) + (js2-print-ast (js2-tagged-template-node-template n))) + +(cl-defstruct (js2-array-node + (:include js2-node) + (:constructor make-js2-array-node (&key (type js2-ARRAYLIT) + (pos js2-ts-cursor) + len elems))) + "AST node for an array literal." + elems) ; list of expressions. [foo,,bar] yields a nil middle element. + +(js2--struct-put 'js2-array-node 'js2-visitor 'js2-visit-array-node) +(js2--struct-put 'js2-array-node 'js2-printer 'js2-print-array-node) + +(defun js2-visit-array-node (n v) + (dolist (e (js2-array-node-elems n)) + (js2-visit-ast e v))) ; Can be nil; e.g. [a, ,b]. + +(defun js2-print-array-node (n i) + (insert (js2-make-pad i) "[") + (let ((elems (js2-array-node-elems n))) + (js2-print-list elems) + (when (and elems (null (car (last elems)))) + (insert ","))) + (insert "]")) + +(cl-defstruct (js2-object-node + (:include js2-node) + (:constructor make-js2-object-node (&key (type js2-OBJECTLIT) + (pos js2-ts-cursor) + len + elems))) + "AST node for an object literal expression. +`elems' is a list of `js2-object-prop-node'." + elems) + +(js2--struct-put 'js2-object-node 'js2-visitor 'js2-visit-object-node) +(js2--struct-put 'js2-object-node 'js2-printer 'js2-print-object-node) + +(defun js2-visit-object-node (n v) + (dolist (e (js2-object-node-elems n)) + (js2-visit-ast e v))) + +(defun js2-print-object-node (n i) + (insert (js2-make-pad i) "{") + (js2-print-list (js2-object-node-elems n)) + (insert "}")) + +(cl-defstruct (js2-class-node + (:include js2-object-node) + (:constructor make-js2-class-node (&key (type js2-CLASS) + (pos js2-ts-cursor) + (form 'CLASS_STATEMENT) + (name "") + extends len elems))) + "AST node for an class expression. +`elems' is a list of `js2-object-prop-node', and `extends' is an +optional `js2-expr-node'" + form ; CLASS_{STATEMENT|EXPRESSION} + name ; class name (a `js2-node-name', or nil if anonymous) + extends ; class heritage (a `js2-expr-node', or nil if none) + ) + +(js2--struct-put 'js2-class-node 'js2-visitor 'js2-visit-class-node) +(js2--struct-put 'js2-class-node 'js2-printer 'js2-print-class-node) + +(defun js2-visit-class-node (n v) + (js2-visit-ast (js2-class-node-name n) v) + (js2-visit-ast (js2-class-node-extends n) v) + (dolist (e (js2-class-node-elems n)) + (js2-visit-ast e v))) + +(defun js2-print-class-node (n i) + (let* ((pad (js2-make-pad i)) + (name (js2-class-node-name n)) + (extends (js2-class-node-extends n)) + (elems (js2-class-node-elems n))) + (insert pad "class") + (when name + (insert " ") + (js2-print-ast name 0)) + (when extends + (insert " extends ") + (js2-print-ast extends)) + (insert " {") + (dolist (elem elems) + (insert "\n") + (if (js2-node-get-prop elem 'STATIC) + (progn (insert (js2-make-pad (1+ i)) "static ") + (js2-print-ast elem 0)) ;; TODO(sdh): indentation isn't quite right + (js2-print-ast elem (1+ i)))) + (insert "\n" pad "}"))) + +(cl-defstruct (js2-computed-prop-name-node + (:include js2-node) + (:constructor make-js2-computed-prop-name-node + (&key + (type js2-LB) + expr + (pos (js2-current-token-beg)) + (len (- js2-ts-cursor + (js2-current-token-beg)))))) + "AST node for a `ComputedPropertyName'." + expr) + +(js2--struct-put 'js2-computed-prop-name-node 'js2-visitor 'js2-visit-computed-prop-name-node) +(js2--struct-put 'js2-computed-prop-name-node 'js2-printer 'js2-print-computed-prop-name-node) + +(defun js2-visit-computed-prop-name-node (n v) + (js2-visit-ast (js2-computed-prop-name-node-expr n) v)) + +(defun js2-print-computed-prop-name-node (n i) + (insert (js2-make-pad i) "[") + (js2-print-ast (js2-computed-prop-name-node-expr n) 0) + (insert "]")) + +(cl-defstruct (js2-object-prop-node + (:include js2-infix-node) + (:constructor make-js2-object-prop-node (&key (type js2-COLON) + (pos js2-ts-cursor) + len left + right op-pos))) + "AST node for an object literal prop:value entry. +The `left' field is the property: a name node, string node, +number node or expression node. The `right' field is a +`js2-node' representing the initializer value. If the property +is abbreviated, the node's `SHORTHAND' property is non-nil and +both fields have the same value.") + +(js2--struct-put 'js2-object-prop-node 'js2-visitor 'js2-visit-infix-node) +(js2--struct-put 'js2-object-prop-node 'js2-printer 'js2-print-object-prop-node) + +(defun js2-print-object-prop-node (n i) + (let* ((left (js2-object-prop-node-left n)) + (right (js2-object-prop-node-right n))) + (js2-print-ast left i) + (if (not (js2-node-get-prop n 'SHORTHAND)) + (progn + (insert ": ") + (js2-print-ast right 0))))) + +(cl-defstruct (js2-method-node + (:include js2-infix-node) + (:constructor make-js2-method-node (&key (pos js2-ts-cursor) + len left right))) + "AST node for a method in an object literal or a class body. +The `left' field is the `js2-name-node' naming the method. +The `right' field is always an anonymous `js2-function-node' with a node +property `METHOD_TYPE' set to 'GET or 'SET. ") + +(js2--struct-put 'js2-method-node 'js2-visitor 'js2-visit-infix-node) +(js2--struct-put 'js2-method-node 'js2-printer 'js2-print-method) + +(defun js2-print-method (n i) + (let* ((pad (js2-make-pad i)) + (left (js2-method-node-left n)) + (right (js2-method-node-right n)) + (type (js2-node-get-prop right 'METHOD_TYPE))) + (insert pad) + (when type + (insert (cdr (assoc type '((GET . "get ") + (SET . "set ") + (ASYNC . "async ") + (FUNCTION . "")))))) + (when (and (js2-function-node-p right) + (eq 'STAR (js2-function-node-generator-type right))) + (insert "*")) + (js2-print-ast left 0) + (js2-print-ast right 0))) + +(cl-defstruct (js2-prop-get-node + (:include js2-infix-node) + (:constructor make-js2-prop-get-node (&key (type js2-GETPROP) + (pos js2-ts-cursor) + len left right))) + "AST node for a dotted property reference, e.g. foo.bar or foo().bar") + +(js2--struct-put 'js2-prop-get-node 'js2-visitor 'js2-visit-prop-get-node) +(js2--struct-put 'js2-prop-get-node 'js2-printer 'js2-print-prop-get-node) + +(defun js2-visit-prop-get-node (n v) + (js2-visit-ast (js2-prop-get-node-left n) v) + (js2-visit-ast (js2-prop-get-node-right n) v)) + +(defun js2-print-prop-get-node (n i) + (insert (js2-make-pad i)) + (js2-print-ast (js2-prop-get-node-left n) 0) + (insert ".") + (js2-print-ast (js2-prop-get-node-right n) 0)) + +(cl-defstruct (js2-elem-get-node + (:include js2-node) + (:constructor make-js2-elem-get-node (&key (type js2-GETELEM) + (pos js2-ts-cursor) + len target element + lb rb))) + "AST node for an array index expression such as foo[bar]." + target ; a `js2-node' - the expression preceding the "." + element ; a `js2-node' - the expression in brackets + lb ; position of left-bracket, nil if omitted + rb) ; position of right-bracket, nil if omitted + +(js2--struct-put 'js2-elem-get-node 'js2-visitor 'js2-visit-elem-get-node) +(js2--struct-put 'js2-elem-get-node 'js2-printer 'js2-print-elem-get-node) + +(defun js2-visit-elem-get-node (n v) + (js2-visit-ast (js2-elem-get-node-target n) v) + (js2-visit-ast (js2-elem-get-node-element n) v)) + +(defun js2-print-elem-get-node (n i) + (insert (js2-make-pad i)) + (js2-print-ast (js2-elem-get-node-target n) 0) + (insert "[") + (js2-print-ast (js2-elem-get-node-element n) 0) + (insert "]")) + +(cl-defstruct (js2-call-node + (:include js2-node) + (:constructor make-js2-call-node (&key (type js2-CALL) + (pos js2-ts-cursor) + len target args + lp rp))) + "AST node for a JavaScript function call." + target ; a `js2-node' evaluating to the function to call + args ; a Lisp list of `js2-node' arguments + lp ; position of open-paren, or nil if missing + rp) ; position of close-paren, or nil if missing + +(js2--struct-put 'js2-call-node 'js2-visitor 'js2-visit-call-node) +(js2--struct-put 'js2-call-node 'js2-printer 'js2-print-call-node) + +(defun js2-visit-call-node (n v) + (js2-visit-ast (js2-call-node-target n) v) + (dolist (arg (js2-call-node-args n)) + (js2-visit-ast arg v))) + +(defun js2-print-call-node (n i) + (insert (js2-make-pad i)) + (js2-print-ast (js2-call-node-target n) 0) + (insert "(") + (js2-print-list (js2-call-node-args n)) + (insert ")")) + +(cl-defstruct (js2-yield-node + (:include js2-node) + (:constructor make-js2-yield-node (&key (type js2-YIELD) + (pos js2-ts-cursor) + len value star-p))) + "AST node for yield statement or expression." + star-p ; whether it's yield* + value) ; optional: value to be yielded + +(js2--struct-put 'js2-yield-node 'js2-visitor 'js2-visit-yield-node) +(js2--struct-put 'js2-yield-node 'js2-printer 'js2-print-yield-node) + +(defun js2-visit-yield-node (n v) + (js2-visit-ast (js2-yield-node-value n) v)) + +(defun js2-print-yield-node (n i) + (insert (js2-make-pad i)) + (insert "yield") + (when (js2-yield-node-star-p n) + (insert "*")) + (when (js2-yield-node-value n) + (insert " ") + (js2-print-ast (js2-yield-node-value n) 0))) + +(cl-defstruct (js2-paren-node + (:include js2-node) + (:constructor make-js2-paren-node (&key (type js2-LP) + (pos js2-ts-cursor) + len expr))) + "AST node for a parenthesized expression. +In particular, used when the parens are syntactically optional, +as opposed to required parens such as those enclosing an if-conditional." + expr) ; `js2-node' + +(js2--struct-put 'js2-paren-node 'js2-visitor 'js2-visit-paren-node) +(js2--struct-put 'js2-paren-node 'js2-printer 'js2-print-paren-node) + +(defun js2-visit-paren-node (n v) + (js2-visit-ast (js2-paren-node-expr n) v)) + +(defun js2-print-paren-node (n i) + (insert (js2-make-pad i)) + (insert "(") + (js2-print-ast (js2-paren-node-expr n) 0) + (insert ")")) + +(cl-defstruct (js2-comp-node + (:include js2-scope) + (:constructor make-js2-comp-node (&key (type js2-ARRAYCOMP) + (pos js2-ts-cursor) + len result + loops filters + form))) + "AST node for an Array comprehension such as [[x,y] for (x in foo) for (y in bar)]." + result ; result expression (just after left-bracket) + loops ; a Lisp list of `js2-comp-loop-node' + filters ; a Lisp list of guard/filter expressions + form ; ARRAY, LEGACY_ARRAY or STAR_GENERATOR + ; SpiderMonkey also supports "legacy generator expressions", but we dont. + ) + +(js2--struct-put 'js2-comp-node 'js2-visitor 'js2-visit-comp-node) +(js2--struct-put 'js2-comp-node 'js2-printer 'js2-print-comp-node) + +(defun js2-visit-comp-node (n v) + (js2-visit-ast (js2-comp-node-result n) v) + (dolist (l (js2-comp-node-loops n)) + (js2-visit-ast l v)) + (dolist (f (js2-comp-node-filters n)) + (js2-visit-ast f v))) + +(defun js2-print-comp-node (n i) + (let ((pad (js2-make-pad i)) + (result (js2-comp-node-result n)) + (loops (js2-comp-node-loops n)) + (filters (js2-comp-node-filters n)) + (legacy-p (eq (js2-comp-node-form n) 'LEGACY_ARRAY)) + (gen-p (eq (js2-comp-node-form n) 'STAR_GENERATOR))) + (insert pad (if gen-p "(" "[")) + (when legacy-p + (js2-print-ast result 0)) + (dolist (l loops) + (when legacy-p + (insert " ")) + (js2-print-ast l 0) + (unless legacy-p + (insert " "))) + (dolist (f filters) + (when legacy-p + (insert " ")) + (insert "if (") + (js2-print-ast f 0) + (insert ")") + (unless legacy-p + (insert " "))) + (unless legacy-p + (js2-print-ast result 0)) + (insert (if gen-p ")" "]")))) + +(cl-defstruct (js2-comp-loop-node + (:include js2-for-in-node) + (:constructor make-js2-comp-loop-node (&key (type js2-FOR) + (pos js2-ts-cursor) + len iterator + object in-pos + foreach-p + each-pos + forof-p + lp rp))) + "AST subtree for each 'for (foo in bar)' loop in an array comprehension.") + +(js2--struct-put 'js2-comp-loop-node 'js2-visitor 'js2-visit-comp-loop) +(js2--struct-put 'js2-comp-loop-node 'js2-printer 'js2-print-comp-loop) + +(defun js2-visit-comp-loop (n v) + (js2-visit-ast (js2-comp-loop-node-iterator n) v) + (js2-visit-ast (js2-comp-loop-node-object n) v)) + +(defun js2-print-comp-loop (n _i) + (insert "for ") + (when (js2-comp-loop-node-foreach-p n) (insert "each ")) + (insert "(") + (js2-print-ast (js2-comp-loop-node-iterator n) 0) + (insert (if (js2-comp-loop-node-forof-p n) + " of " " in ")) + (js2-print-ast (js2-comp-loop-node-object n) 0) + (insert ")")) + +(cl-defstruct (js2-empty-expr-node + (:include js2-node) + (:constructor make-js2-empty-expr-node (&key (type js2-EMPTY) + (pos (js2-current-token-beg)) + len))) + "AST node for an empty expression.") + +(js2--struct-put 'js2-empty-expr-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-empty-expr-node 'js2-printer 'js2-print-none) + +(cl-defstruct (js2-xml-node + (:include js2-block-node) + (:constructor make-js2-xml-node (&key (type js2-XML) + (pos (js2-current-token-beg)) + len kids))) + "AST node for initial parse of E4X literals. +The kids field is a list of XML fragments, each a `js2-string-node' or +a `js2-xml-js-expr-node'. Equivalent to Rhino's XmlLiteral node.") + +(js2--struct-put 'js2-xml-node 'js2-visitor 'js2-visit-block) +(js2--struct-put 'js2-xml-node 'js2-printer 'js2-print-xml-node) + +(defun js2-print-xml-node (n i) + (dolist (kid (js2-xml-node-kids n)) + (js2-print-ast kid i))) + +(cl-defstruct (js2-xml-js-expr-node + (:include js2-xml-node) + (:constructor make-js2-xml-js-expr-node (&key (type js2-XML) + (pos js2-ts-cursor) + len expr))) + "AST node for an embedded JavaScript {expression} in an E4X literal. +The start and end fields correspond to the curly-braces." + expr) ; a `js2-expr-node' of some sort + +(js2--struct-put 'js2-xml-js-expr-node 'js2-visitor 'js2-visit-xml-js-expr) +(js2--struct-put 'js2-xml-js-expr-node 'js2-printer 'js2-print-xml-js-expr) + +(defun js2-visit-xml-js-expr (n v) + (js2-visit-ast (js2-xml-js-expr-node-expr n) v)) + +(defun js2-print-xml-js-expr (n i) + (insert (js2-make-pad i)) + (insert "{") + (js2-print-ast (js2-xml-js-expr-node-expr n) 0) + (insert "}")) + +(cl-defstruct (js2-xml-dot-query-node + (:include js2-infix-node) + (:constructor make-js2-xml-dot-query-node (&key (type js2-DOTQUERY) + (pos js2-ts-cursor) + op-pos len left + right rp))) + "AST node for an E4X foo.(bar) filter expression. +Note that the left-paren is automatically the character immediately +following the dot (.) in the operator. No whitespace is permitted +between the dot and the lp by the scanner." + rp) + +(js2--struct-put 'js2-xml-dot-query-node 'js2-visitor 'js2-visit-infix-node) +(js2--struct-put 'js2-xml-dot-query-node 'js2-printer 'js2-print-xml-dot-query) + +(defun js2-print-xml-dot-query (n i) + (insert (js2-make-pad i)) + (js2-print-ast (js2-xml-dot-query-node-left n) 0) + (insert ".(") + (js2-print-ast (js2-xml-dot-query-node-right n) 0) + (insert ")")) + +(cl-defstruct (js2-xml-ref-node + (:include js2-node) + (:constructor nil)) ; abstract + "Base type for E4X XML attribute-access or property-get expressions. +Such expressions can take a variety of forms. The general syntax has +three parts: + + - (optional) an @ (specifying an attribute access) + - (optional) a namespace (a `js2-name-node') and double-colon + - (required) either a `js2-name-node' or a bracketed [expression] + +The property-name expressions (examples: ns::name, @name) are +represented as `js2-xml-prop-ref' nodes. The bracketed-expression +versions (examples: ns::[name], @[name]) become `js2-xml-elem-ref' nodes. + +This node type (or more specifically, its subclasses) will sometimes +be the right-hand child of a `js2-prop-get-node' or a +`js2-infix-node' of type `js2-DOTDOT', the .. xml-descendants operator. +The `js2-xml-ref-node' may also be a standalone primary expression with +no explicit target, which is valid in certain expression contexts such as + + company..employee.(@id < 100) + +in this case, the @id is a `js2-xml-ref' that is part of an infix `<' +expression whose parent is a `js2-xml-dot-query-node'." + namespace + at-pos + colon-pos) + +(defsubst js2-xml-ref-node-attr-access-p (node) + "Return non-nil if this expression began with an @-token." + (and (numberp (js2-xml-ref-node-at-pos node)) + (cl-plusp (js2-xml-ref-node-at-pos node)))) + +(cl-defstruct (js2-xml-prop-ref-node + (:include js2-xml-ref-node) + (:constructor make-js2-xml-prop-ref-node (&key (type js2-REF_NAME) + (pos (js2-current-token-beg)) + len propname + namespace at-pos + colon-pos))) + "AST node for an E4X XML [expr] property-ref expression. +The JavaScript syntax is an optional @, an optional ns::, and a name. + + [ `@' ] [ name `::' ] name + +Examples include name, ns::name, ns::*, *::name, *::*, @attr, @ns::attr, +@ns::*, @*::attr, @*::*, and @*. + +The node starts at the @ token, if present. Otherwise it starts at the +namespace name. The node bounds extend through the closing right-bracket, +or if it is missing due to a syntax error, through the end of the index +expression." + propname) + +(js2--struct-put 'js2-xml-prop-ref-node 'js2-visitor 'js2-visit-xml-prop-ref-node) +(js2--struct-put 'js2-xml-prop-ref-node 'js2-printer 'js2-print-xml-prop-ref-node) + +(defun js2-visit-xml-prop-ref-node (n v) + (js2-visit-ast (js2-xml-prop-ref-node-namespace n) v) + (js2-visit-ast (js2-xml-prop-ref-node-propname n) v)) + +(defun js2-print-xml-prop-ref-node (n i) + (insert (js2-make-pad i)) + (if (js2-xml-ref-node-attr-access-p n) + (insert "@")) + (when (js2-xml-prop-ref-node-namespace n) + (js2-print-ast (js2-xml-prop-ref-node-namespace n) 0) + (insert "::")) + (if (js2-xml-prop-ref-node-propname n) + (js2-print-ast (js2-xml-prop-ref-node-propname n) 0))) + +(cl-defstruct (js2-xml-elem-ref-node + (:include js2-xml-ref-node) + (:constructor make-js2-xml-elem-ref-node (&key (type js2-REF_MEMBER) + (pos (js2-current-token-beg)) + len expr lb rb + namespace at-pos + colon-pos))) + "AST node for an E4X XML [expr] member-ref expression. +Syntax: + + [ `@' ] [ name `::' ] `[' expr `]' + +Examples include ns::[expr], @ns::[expr], @[expr], *::[expr] and @*::[expr]. + +Note that the form [expr] (i.e. no namespace or attribute-qualifier) +is not a legal E4X XML element-ref expression, since it's already used +for standard JavaScript element-get array indexing. Hence, a +`js2-xml-elem-ref-node' always has either the attribute-qualifier, a +non-nil namespace node, or both. + +The node starts at the @ token, if present. Otherwise it starts +at the namespace name. The node bounds extend through the closing +right-bracket, or if it is missing due to a syntax error, through the +end of the index expression." + expr ; the bracketed index expression + lb + rb) + +(js2--struct-put 'js2-xml-elem-ref-node 'js2-visitor 'js2-visit-xml-elem-ref-node) +(js2--struct-put 'js2-xml-elem-ref-node 'js2-printer 'js2-print-xml-elem-ref-node) + +(defun js2-visit-xml-elem-ref-node (n v) + (js2-visit-ast (js2-xml-elem-ref-node-namespace n) v) + (js2-visit-ast (js2-xml-elem-ref-node-expr n) v)) + +(defun js2-print-xml-elem-ref-node (n i) + (insert (js2-make-pad i)) + (if (js2-xml-ref-node-attr-access-p n) + (insert "@")) + (when (js2-xml-elem-ref-node-namespace n) + (js2-print-ast (js2-xml-elem-ref-node-namespace n) 0) + (insert "::")) + (insert "[") + (if (js2-xml-elem-ref-node-expr n) + (js2-print-ast (js2-xml-elem-ref-node-expr n) 0)) + (insert "]")) + +;;; Placeholder nodes for when we try parsing the XML literals structurally. + +(cl-defstruct (js2-xml-start-tag-node + (:include js2-xml-node) + (:constructor make-js2-xml-start-tag-node (&key (type js2-XML) + (pos js2-ts-cursor) + len name attrs kids + empty-p))) + "AST node for an XML start-tag. Not currently used. +The `kids' field is a Lisp list of child content nodes." + name ; a `js2-xml-name-node' + attrs ; a Lisp list of `js2-xml-attr-node' + empty-p) ; t if this is an empty element such as <foo bar="baz"/> + +(js2--struct-put 'js2-xml-start-tag-node 'js2-visitor 'js2-visit-xml-start-tag) +(js2--struct-put 'js2-xml-start-tag-node 'js2-printer 'js2-print-xml-start-tag) + +(defun js2-visit-xml-start-tag (n v) + (js2-visit-ast (js2-xml-start-tag-node-name n) v) + (dolist (attr (js2-xml-start-tag-node-attrs n)) + (js2-visit-ast attr v)) + (js2-visit-block n v)) + +(defun js2-print-xml-start-tag (n i) + (insert (js2-make-pad i) "<") + (js2-print-ast (js2-xml-start-tag-node-name n) 0) + (when (js2-xml-start-tag-node-attrs n) + (insert " ") + (js2-print-list (js2-xml-start-tag-node-attrs n) " ")) + (insert ">")) + +;; I -think- I'm going to make the parent node the corresponding start-tag, +;; and add the end-tag to the kids list of the parent as well. +(cl-defstruct (js2-xml-end-tag-node + (:include js2-xml-node) + (:constructor make-js2-xml-end-tag-node (&key (type js2-XML) + (pos js2-ts-cursor) + len name))) + "AST node for an XML end-tag. Not currently used." + name) ; a `js2-xml-name-node' + +(js2--struct-put 'js2-xml-end-tag-node 'js2-visitor 'js2-visit-xml-end-tag) +(js2--struct-put 'js2-xml-end-tag-node 'js2-printer 'js2-print-xml-end-tag) + +(defun js2-visit-xml-end-tag (n v) + (js2-visit-ast (js2-xml-end-tag-node-name n) v)) + +(defun js2-print-xml-end-tag (n i) + (insert (js2-make-pad i)) + (insert "</") + (js2-print-ast (js2-xml-end-tag-node-name n) 0) + (insert ">")) + +(cl-defstruct (js2-xml-name-node + (:include js2-xml-node) + (:constructor make-js2-xml-name-node (&key (type js2-XML) + (pos js2-ts-cursor) + len namespace kids))) + "AST node for an E4X XML name. Not currently used. +Any XML name can be qualified with a namespace, hence the namespace field. +Further, any E4X name can be comprised of arbitrary JavaScript {} expressions. +The kids field is a list of `js2-name-node' and `js2-xml-js-expr-node'. +For a simple name, the kids list has exactly one node, a `js2-name-node'." + namespace) ; a `js2-string-node' + +(js2--struct-put 'js2-xml-name-node 'js2-visitor 'js2-visit-xml-name-node) +(js2--struct-put 'js2-xml-name-node 'js2-printer 'js2-print-xml-name-node) + +(defun js2-visit-xml-name-node (n v) + (js2-visit-ast (js2-xml-name-node-namespace n) v)) + +(defun js2-print-xml-name-node (n i) + (insert (js2-make-pad i)) + (when (js2-xml-name-node-namespace n) + (js2-print-ast (js2-xml-name-node-namespace n) 0) + (insert "::")) + (dolist (kid (js2-xml-name-node-kids n)) + (js2-print-ast kid 0))) + +(cl-defstruct (js2-xml-pi-node + (:include js2-xml-node) + (:constructor make-js2-xml-pi-node (&key (type js2-XML) + (pos js2-ts-cursor) + len name attrs))) + "AST node for an E4X XML processing instruction. Not currently used." + name ; a `js2-xml-name-node' + attrs) ; a list of `js2-xml-attr-node' + +(js2--struct-put 'js2-xml-pi-node 'js2-visitor 'js2-visit-xml-pi-node) +(js2--struct-put 'js2-xml-pi-node 'js2-printer 'js2-print-xml-pi-node) + +(defun js2-visit-xml-pi-node (n v) + (js2-visit-ast (js2-xml-pi-node-name n) v) + (dolist (attr (js2-xml-pi-node-attrs n)) + (js2-visit-ast attr v))) + +(defun js2-print-xml-pi-node (n i) + (insert (js2-make-pad i) "<?") + (js2-print-ast (js2-xml-pi-node-name n)) + (when (js2-xml-pi-node-attrs n) + (insert " ") + (js2-print-list (js2-xml-pi-node-attrs n))) + (insert "?>")) + +(cl-defstruct (js2-xml-cdata-node + (:include js2-xml-node) + (:constructor make-js2-xml-cdata-node (&key (type js2-XML) + (pos js2-ts-cursor) + len content))) + "AST node for a CDATA escape section. Not currently used." + content) ; a `js2-string-node' with node-property 'quote-type 'cdata + +(js2--struct-put 'js2-xml-cdata-node 'js2-visitor 'js2-visit-xml-cdata-node) +(js2--struct-put 'js2-xml-cdata-node 'js2-printer 'js2-print-xml-cdata-node) + +(defun js2-visit-xml-cdata-node (n v) + (js2-visit-ast (js2-xml-cdata-node-content n) v)) + +(defun js2-print-xml-cdata-node (n i) + (insert (js2-make-pad i)) + (js2-print-ast (js2-xml-cdata-node-content n))) + +(cl-defstruct (js2-xml-attr-node + (:include js2-xml-node) + (:constructor make-js2-attr-node (&key (type js2-XML) + (pos js2-ts-cursor) + len name value + eq-pos quote-type))) + "AST node representing a foo=\\='bar\\=' XML attribute value. Not yet used." + name ; a `js2-xml-name-node' + value ; a `js2-xml-name-node' + eq-pos ; buffer position of "=" sign + quote-type) ; 'single or 'double + +(js2--struct-put 'js2-xml-attr-node 'js2-visitor 'js2-visit-xml-attr-node) +(js2--struct-put 'js2-xml-attr-node 'js2-printer 'js2-print-xml-attr-node) + +(defun js2-visit-xml-attr-node (n v) + (js2-visit-ast (js2-xml-attr-node-name n) v) + (js2-visit-ast (js2-xml-attr-node-value n) v)) + +(defun js2-print-xml-attr-node (n i) + (let ((quote (if (eq (js2-xml-attr-node-quote-type n) 'single) + "'" + "\""))) + (insert (js2-make-pad i)) + (js2-print-ast (js2-xml-attr-node-name n) 0) + (insert "=" quote) + (js2-print-ast (js2-xml-attr-node-value n) 0) + (insert quote))) + +(cl-defstruct (js2-xml-text-node + (:include js2-xml-node) + (:constructor make-js2-text-node (&key (type js2-XML) + (pos js2-ts-cursor) + len content))) + "AST node for an E4X XML text node. Not currently used." + content) ; a Lisp list of `js2-string-node' and `js2-xml-js-expr-node' + +(js2--struct-put 'js2-xml-text-node 'js2-visitor 'js2-visit-xml-text-node) +(js2--struct-put 'js2-xml-text-node 'js2-printer 'js2-print-xml-text-node) + +(defun js2-visit-xml-text-node (n v) + (js2-visit-ast (js2-xml-text-node-content n) v)) + +(defun js2-print-xml-text-node (n i) + (insert (js2-make-pad i)) + (dolist (kid (js2-xml-text-node-content n)) + (js2-print-ast kid))) + +(cl-defstruct (js2-xml-comment-node + (:include js2-xml-node) + (:constructor make-js2-xml-comment-node (&key (type js2-XML) + (pos js2-ts-cursor) + len))) + "AST node for E4X XML comment. Not currently used.") + +(js2--struct-put 'js2-xml-comment-node 'js2-visitor 'js2-visit-none) +(js2--struct-put 'js2-xml-comment-node 'js2-printer 'js2-print-xml-comment) + +(defun js2-print-xml-comment (n i) + (insert (js2-make-pad i) + (js2-node-string n))) + +;;; Node utilities + +(defsubst js2-node-line (n) + "Fetch the source line number at the start of node N. +This is O(n) in the length of the source buffer; use prudently." + (1+ (count-lines (point-min) (js2-node-abs-pos n)))) + +(defsubst js2-block-node-kid (n i) + "Return child I of node N, or nil if there aren't that many." + (nth i (js2-block-node-kids n))) + +(defsubst js2-block-node-first (n) + "Return first child of block node N, or nil if there is none." + (cl-first (js2-block-node-kids n))) + +(defun js2-node-root (n) + "Return the root of the AST containing N. +If N has no parent pointer, returns N." + (let ((parent (js2-node-parent n))) + (if parent + (js2-node-root parent) + n))) + +(defsubst js2-node-short-name (n) + "Return the short name of node N as a string, e.g. `js2-if-node'." + (let ((name (symbol-name (aref n 0)))) + (if (string-prefix-p "cl-struct-" name) + (substring (symbol-name (aref n 0)) + (length "cl-struct-")) + name))) + +(defun js2-node-child-list (node) + "Return the child list for NODE, a Lisp list of nodes. +Works for block nodes, array nodes, obj literals, funarg lists, +var decls and try nodes (for catch clauses). Note that you should call +`js2-block-node-kids' on the function body for the body statements. +Returns nil for zero-length child lists or unsupported nodes." + (cond + ((js2-function-node-p node) + (js2-function-node-params node)) + ((js2-block-node-p node) + (js2-block-node-kids node)) + ((js2-try-node-p node) + (js2-try-node-catch-clauses node)) + ((js2-array-node-p node) + (js2-array-node-elems node)) + ((js2-object-node-p node) + (js2-object-node-elems node)) + ((js2-call-node-p node) + (js2-call-node-args node)) + ((js2-new-node-p node) + (js2-new-node-args node)) + ((js2-var-decl-node-p node) + (js2-var-decl-node-kids node)) + (t + nil))) + +(defun js2-node-set-child-list (node kids) + "Set the child list for NODE to KIDS." + (cond + ((js2-function-node-p node) + (setf (js2-function-node-params node) kids)) + ((js2-block-node-p node) + (setf (js2-block-node-kids node) kids)) + ((js2-try-node-p node) + (setf (js2-try-node-catch-clauses node) kids)) + ((js2-array-node-p node) + (setf (js2-array-node-elems node) kids)) + ((js2-object-node-p node) + (setf (js2-object-node-elems node) kids)) + ((js2-call-node-p node) + (setf (js2-call-node-args node) kids)) + ((js2-new-node-p node) + (setf (js2-new-node-args node) kids)) + ((js2-var-decl-node-p node) + (setf (js2-var-decl-node-kids node) kids)) + (t + (error "Unsupported node type: %s" (js2-node-short-name node)))) + kids) + +;; All because Common Lisp doesn't support multiple inheritance for defstructs. +(defconst js2-paren-expr-nodes + '(cl-struct-js2-comp-loop-node + cl-struct-js2-comp-node + cl-struct-js2-call-node + cl-struct-js2-catch-node + cl-struct-js2-do-node + cl-struct-js2-elem-get-node + cl-struct-js2-for-in-node + cl-struct-js2-for-node + cl-struct-js2-function-node + cl-struct-js2-if-node + cl-struct-js2-let-node + cl-struct-js2-new-node + cl-struct-js2-paren-node + cl-struct-js2-switch-node + cl-struct-js2-while-node + cl-struct-js2-with-node + cl-struct-js2-xml-dot-query-node) + "Node types that can have a parenthesized child expression. +In particular, nodes that respond to `js2-node-lp' and `js2-node-rp'.") + +(defsubst js2-paren-expr-node-p (node) + "Return t for nodes that typically have a parenthesized child expression. +Useful for computing the indentation anchors for arg-lists and conditions. +Note that it may return a false positive, for instance when NODE is +a `js2-new-node' and there are no arguments or parentheses." + (memq (aref node 0) js2-paren-expr-nodes)) + +;; Fake polymorphism... yech. +(defun js2-node-lp (node) + "Return relative left-paren position for NODE, if applicable. +For `js2-elem-get-node' structs, returns left-bracket position. +Note that the position may be nil in the case of a parse error." + (cond + ((js2-elem-get-node-p node) + (js2-elem-get-node-lb node)) + ((js2-loop-node-p node) + (js2-loop-node-lp node)) + ((js2-function-node-p node) + (js2-function-node-lp node)) + ((js2-if-node-p node) + (js2-if-node-lp node)) + ((js2-new-node-p node) + (js2-new-node-lp node)) + ((js2-call-node-p node) + (js2-call-node-lp node)) + ((js2-paren-node-p node) + 0) + ((js2-switch-node-p node) + (js2-switch-node-lp node)) + ((js2-catch-node-p node) + (js2-catch-node-lp node)) + ((js2-let-node-p node) + (js2-let-node-lp node)) + ((js2-comp-node-p node) + 0) + ((js2-with-node-p node) + (js2-with-node-lp node)) + ((js2-xml-dot-query-node-p node) + (1+ (js2-infix-node-op-pos node))) + (t + (error "Unsupported node type: %s" (js2-node-short-name node))))) + +;; Fake polymorphism... blech. +(defun js2-node-rp (node) + "Return relative right-paren position for NODE, if applicable. +For `js2-elem-get-node' structs, returns right-bracket position. +Note that the position may be nil in the case of a parse error." + (cond + ((js2-elem-get-node-p node) + (js2-elem-get-node-rb node)) + ((js2-loop-node-p node) + (js2-loop-node-rp node)) + ((js2-function-node-p node) + (js2-function-node-rp node)) + ((js2-if-node-p node) + (js2-if-node-rp node)) + ((js2-new-node-p node) + (js2-new-node-rp node)) + ((js2-call-node-p node) + (js2-call-node-rp node)) + ((js2-paren-node-p node) + (1- (js2-node-len node))) + ((js2-switch-node-p node) + (js2-switch-node-rp node)) + ((js2-catch-node-p node) + (js2-catch-node-rp node)) + ((js2-let-node-p node) + (js2-let-node-rp node)) + ((js2-comp-node-p node) + (1- (js2-node-len node))) + ((js2-with-node-p node) + (js2-with-node-rp node)) + ((js2-xml-dot-query-node-p node) + (1+ (js2-xml-dot-query-node-rp node))) + (t + (error "Unsupported node type: %s" (js2-node-short-name node))))) + +(defsubst js2-node-first-child (node) + "Return the first element of `js2-node-child-list' for NODE." + (car (js2-node-child-list node))) + +(defsubst js2-node-last-child (node) + "Return the last element of `js2-node-last-child' for NODE." + (car (last (js2-node-child-list node)))) + +(defun js2-node-prev-sibling (node) + "Return the previous statement in parent. +Works for parents supported by `js2-node-child-list'. +Returns nil if NODE is not in the parent, or PARENT is +not a supported node, or if NODE is the first child." + (let* ((p (js2-node-parent node)) + (kids (js2-node-child-list p)) + (sib (car kids))) + (while (and kids + (not (eq node (cadr kids)))) + (setq kids (cdr kids) + sib (car kids))) + sib)) + +(defun js2-node-next-sibling (node) + "Return the next statement in parent block. +Returns nil if NODE is not in the block, or PARENT is not +a block node, or if NODE is the last statement." + (let* ((p (js2-node-parent node)) + (kids (js2-node-child-list p))) + (while (and kids + (not (eq node (car kids)))) + (setq kids (cdr kids))) + (cadr kids))) + +(defun js2-node-find-child-before (pos parent &optional after) + "Find the last child that starts before POS in parent. +If AFTER is non-nil, returns first child starting after POS. +POS is an absolute buffer position. PARENT is any node +supported by `js2-node-child-list'. +Returns nil if no applicable child is found." + (let ((kids (if (js2-function-node-p parent) + (js2-block-node-kids (js2-function-node-body parent)) + (js2-node-child-list parent))) + (beg (js2-node-abs-pos (if (js2-function-node-p parent) + (js2-function-node-body parent) + parent))) + kid result fn + (continue t)) + (setq fn (if after '>= '<)) + (while (and kids continue) + (setq kid (car kids)) + (if (funcall fn (+ beg (js2-node-pos kid)) pos) + (setq result kid + continue (not after)) + (setq continue after)) + (setq kids (cdr kids))) + result)) + +(defun js2-node-find-child-after (pos parent) + "Find first child that starts after POS in parent. +POS is an absolute buffer position. PARENT is any node +supported by `js2-node-child-list'. +Returns nil if no applicable child is found." + (js2-node-find-child-before pos parent 'after)) + +(defun js2-node-replace-child (pos parent new-node) + "Replace node at index POS in PARENT with NEW-NODE. +Only works for parents supported by `js2-node-child-list'." + (let ((kids (js2-node-child-list parent)) + (i 0)) + (while (< i pos) + (setq kids (cdr kids) + i (1+ i))) + (setcar kids new-node) + (js2-node-add-children parent new-node))) + +(defun js2-node-buffer (n) + "Return the buffer associated with AST N. +Returns nil if the buffer is not set as a property on the root +node, or if parent links were not recorded during parsing." + (let ((root (js2-node-root n))) + (and root + (js2-ast-root-p root) + (js2-ast-root-buffer root)))) + +(defun js2-block-node-push (n kid) + "Push js2-node KID onto the end of js2-block-node N's child list. +KID is always added to the -end- of the kids list. +Function also calls `js2-node-add-children' to add the parent link." + (let ((kids (js2-node-child-list n))) + (if kids + (setcdr kids (nconc (cdr kids) (list kid))) + (js2-node-set-child-list n (list kid))) + (js2-node-add-children n kid))) + +(defun js2-node-string (node) + (with-current-buffer (or (js2-node-buffer node) + (error "No buffer available for node %s" node)) + (let ((pos (js2-node-abs-pos node))) + (buffer-substring-no-properties pos (+ pos (js2-node-len node)))))) + +;; Container for storing the node we're looking for in a traversal. +(js2-deflocal js2-discovered-node nil) + +;; Keep track of absolute node position during traversals. +(js2-deflocal js2-visitor-offset nil) + +(js2-deflocal js2-node-search-point nil) + +(when js2-mode-dev-mode-p + (defun js2-find-node-at-point () + (interactive) + (let ((node (js2-node-at-point))) + (message "%s" (or node "No node found at point")))) + (defun js2-node-name-at-point () + (interactive) + (let ((node (js2-node-at-point))) + (message "%s" (if node + (js2-node-short-name node) + "No node found at point."))))) + +(defun js2-node-at-point (&optional pos skip-comments) + "Return AST node at POS, a buffer position, defaulting to current point. +The `js2-mode-ast' variable must be set to the current parse tree. +Signals an error if the AST (`js2-mode-ast') is nil. +Always returns a node - if it can't find one, it returns the root. +If SKIP-COMMENTS is non-nil, comment nodes are ignored." + (let ((ast js2-mode-ast) + result) + (unless ast + (error "No JavaScript AST available")) + ;; Look through comments first, since they may be inside nodes that + ;; would otherwise report a match. + (setq pos (or pos (point)) + result (if (> pos (js2-node-abs-end ast)) + ast + (if (not skip-comments) + (js2-comment-at-point pos)))) + (unless result + (setq js2-discovered-node nil + js2-visitor-offset 0 + js2-node-search-point pos) + (unwind-protect + (catch 'js2-visit-done + (js2-visit-ast ast #'js2-node-at-point-visitor)) + (setq js2-visitor-offset nil + js2-node-search-point nil)) + (setq result js2-discovered-node)) + ;; may have found a comment beyond end of last child node, + ;; since visiting the ast-root looks at the comment-list last. + (if (and skip-comments + (js2-comment-node-p result)) + (setq result nil)) + (or result js2-mode-ast))) + +(defun js2-node-at-point-visitor (node end-p) + (let ((rel-pos (js2-node-pos node)) + abs-pos + abs-end + (point js2-node-search-point)) + (cond + (end-p + ;; this evaluates to a non-nil return value, even if it's zero + (cl-decf js2-visitor-offset rel-pos)) + ;; we already looked for comments before visiting, and don't want them now + ((js2-comment-node-p node) + nil) + (t + (setq abs-pos (cl-incf js2-visitor-offset rel-pos) + ;; we only want to use the node if the point is before + ;; the last character position in the node, so we decrement + ;; the absolute end by 1. + abs-end (+ abs-pos (js2-node-len node) -1)) + (cond + ;; If this node starts after search-point, stop the search. + ((> abs-pos point) + (throw 'js2-visit-done nil)) + ;; If this node ends before the search-point, don't check kids. + ((> point abs-end) + nil) + (t + ;; Otherwise point is within this node, possibly in a child. + (setq js2-discovered-node node) + t)))))) ; keep processing kids to look for more specific match + +(defsubst js2-block-comment-p (node) + "Return non-nil if NODE is a comment node of format `jsdoc' or `block'." + (and (js2-comment-node-p node) + (memq (js2-comment-node-format node) '(jsdoc block)))) + +;; TODO: put the comments in a vector and binary-search them instead +(defun js2-comment-at-point (&optional pos) + "Look through scanned comment nodes for one containing POS. +POS is a buffer position that defaults to current point. +Function returns nil if POS was not in any comment node." + (let ((ast js2-mode-ast) + (x (or pos (point))) + beg end) + (unless ast + (error "No JavaScript AST available")) + (catch 'done + ;; Comments are stored in lexical order. + (dolist (comment (js2-ast-root-comments ast) nil) + (setq beg (js2-node-abs-pos comment) + end (+ beg (js2-node-len comment))) + (if (and (>= x beg) + (<= x end)) + (throw 'done comment)))))) + +(defun js2-comments-between (start end comments-list) + "Return comment nodes between START and END, nil if not found. +START and END are absolute positions in current buffer. +COMMENTS-LIST is the comments list to check." + (let (comments c-start c-end) + (nreverse + (dolist (comment comments-list comments) + (setq c-start (js2-node-abs-pos comment) + c-end (1- (+ c-start (js2-node-len comment)))) + (unless (or (< c-end start) + (> c-start end)) + (push comment comments)))))) + +(defun js2-mode-find-parent-fn (node) + "Find function enclosing NODE. +Returns nil if NODE is not inside a function." + (setq node (js2-node-parent node)) + (while (and node (not (js2-function-node-p node))) + (setq node (js2-node-parent node))) + (and (js2-function-node-p node) node)) + +(defun js2-mode-find-enclosing-fn (node) + "Find function or root enclosing NODE." + (if (js2-ast-root-p node) + node + (setq node (js2-node-parent node)) + (while (not (or (js2-ast-root-p node) + (js2-function-node-p node))) + (setq node (js2-node-parent node))) + node)) + + (defun js2-mode-find-enclosing-node (beg end) + "Find node fully enclosing BEG and END." + (let ((node (js2-node-at-point beg)) + pos + (continue t)) + (while continue + (if (or (js2-ast-root-p node) + (and + (<= (setq pos (js2-node-abs-pos node)) beg) + (>= (+ pos (js2-node-len node)) end))) + (setq continue nil) + (setq node (js2-node-parent node)))) + node)) + +(defun js2-node-parent-script-or-fn (node) + "Find script or function immediately enclosing NODE. +If NODE is the ast-root, returns nil." + (if (js2-ast-root-p node) + nil + (setq node (js2-node-parent node)) + (while (and node (not (or (js2-function-node-p node) + (js2-script-node-p node)))) + (setq node (js2-node-parent node))) + node)) + +(defun js2-node-is-descendant (node ancestor) + "Return t if NODE is a descendant of ANCESTOR." + (while (and node + (not (eq node ancestor))) + (setq node (js2-node-parent node))) + node) + +;;; visitor infrastructure + +(defun js2-visit-none (_node _callback) + "Visitor for AST node that have no node children." + nil) + +(defun js2-print-none (_node _indent) + "Visitor for AST node with no printed representation.") + +(defun js2-print-body (node indent) + "Print a statement, or a block without braces." + (if (js2-block-node-p node) + (dolist (kid (js2-block-node-kids node)) + (js2-print-ast kid indent)) + (js2-print-ast node indent))) + +(defun js2-print-list (args &optional delimiter) + (cl-loop with len = (length args) + for arg in args + for count from 1 + do + (when arg (js2-print-ast arg 0)) + (if (< count len) + (insert (or delimiter ", "))))) + +(defun js2-print-tree (ast) + "Prints an AST to the current buffer. +Makes `js2-ast-parent-nodes' available to the printer functions." + (let ((max-lisp-eval-depth (max max-lisp-eval-depth 1500))) + (js2-print-ast ast))) + +(defun js2-print-ast (node &optional indent) + "Helper function for printing AST nodes. +Requires `js2-ast-parent-nodes' to be non-nil. +You should use `js2-print-tree' instead of this function." + (let ((printer (get (aref node 0) 'js2-printer)) + (i (or indent 0))) + ;; TODO: wedge comments in here somewhere + (if printer + (funcall printer node i)))) + +(defconst js2-side-effecting-tokens + (let ((tokens (make-bool-vector js2-num-tokens nil))) + (dolist (tt (list js2-ASSIGN + js2-ASSIGN_ADD + js2-ASSIGN_BITAND + js2-ASSIGN_BITOR + js2-ASSIGN_BITXOR + js2-ASSIGN_DIV + js2-ASSIGN_LSH + js2-ASSIGN_MOD + js2-ASSIGN_MUL + js2-ASSIGN_RSH + js2-ASSIGN_SUB + js2-ASSIGN_URSH + js2-ASSIGN_EXPON + js2-BLOCK + js2-BREAK + js2-CALL + js2-CATCH + js2-CATCH_SCOPE + js2-CLASS + js2-CONST + js2-CONTINUE + js2-DEBUGGER + js2-DEC + js2-DELPROP + js2-DEL_REF + js2-DO + js2-ELSE + js2-EMPTY + js2-ENTERWITH + js2-EXPORT + js2-EXPR_RESULT + js2-FINALLY + js2-FOR + js2-FUNCTION + js2-GOTO + js2-IF + js2-IFEQ + js2-IFNE + js2-IMPORT + js2-INC + js2-JSR + js2-LABEL + js2-LEAVEWITH + js2-LET + js2-LETEXPR + js2-LOCAL_BLOCK + js2-LOOP + js2-NEW + js2-REF_CALL + js2-RETHROW + js2-RETURN + js2-RETURN_RESULT + js2-SEMI + js2-SETELEM + js2-SETELEM_OP + js2-SETNAME + js2-SETPROP + js2-SETPROP_OP + js2-SETVAR + js2-SET_REF + js2-SET_REF_OP + js2-SWITCH + js2-TARGET + js2-THROW + js2-TRY + js2-VAR + js2-WHILE + js2-WITH + js2-WITHEXPR + js2-YIELD)) + (aset tokens tt t)) + tokens)) + +(defun js2-node-has-side-effects (node) + "Return t if NODE has side effects." + (when node ; makes it easier to handle malformed expressions + (let ((tt (js2-node-type node))) + (cond + ;; This doubtless needs some work, since EXPR_VOID is used + ;; in several ways in Rhino and I may not have caught them all. + ;; I'll wait for people to notice incorrect warnings. + ((and (= tt js2-EXPR_VOID) + (js2-expr-stmt-node-p node)) ; but not if EXPR_RESULT + (let ((expr (js2-expr-stmt-node-expr node))) + (or (js2-node-has-side-effects expr) + (when (js2-string-node-p expr) + (member (js2-string-node-value expr) '("use strict" "use asm")))))) + ((= tt js2-AWAIT) t) + ((= tt js2-COMMA) + (js2-node-has-side-effects (js2-infix-node-right node))) + ((or (= tt js2-AND) + (= tt js2-OR)) + (or (js2-node-has-side-effects (js2-infix-node-right node)) + (js2-node-has-side-effects (js2-infix-node-left node)))) + ((= tt js2-HOOK) + (and (js2-node-has-side-effects (js2-cond-node-true-expr node)) + (js2-node-has-side-effects (js2-cond-node-false-expr node)))) + ((js2-paren-node-p node) + (js2-node-has-side-effects (js2-paren-node-expr node))) + ((= tt js2-ERROR) ; avoid cascaded error messages + nil) + ((or (and js2-instanceof-has-side-effects (= tt js2-INSTANCEOF)) + (and js2-getprop-has-side-effects (= tt js2-GETPROP))) + t) + (t + (aref js2-side-effecting-tokens tt)))))) + +(defconst js2-stmt-node-types + (list js2-BLOCK + js2-BREAK + js2-CONTINUE + js2-DEFAULT ; e4x "default xml namespace" statement + js2-DO + js2-EXPORT + js2-EXPR_RESULT + js2-EXPR_VOID + js2-FOR + js2-IF + js2-IMPORT + js2-RETURN + js2-SWITCH + js2-THROW + js2-TRY + js2-WHILE + js2-WITH) + "Node types that only appear in statement contexts. +The list does not include nodes that always appear as the child +of another specific statement type, such as switch-cases, +catch and finally blocks, and else-clauses. The list also excludes +nodes like yield, let and var, which may appear in either expression +or statement context, and in the latter context always have a +`js2-expr-stmt-node' parent. Finally, the list does not include +functions or scripts, which are treated separately from statements +by the JavaScript parser and runtime.") + +(defun js2-stmt-node-p (node) + "Heuristic for figuring out if NODE is a statement. +Some node types can appear in either an expression context or a +statement context, e.g. let-nodes, yield-nodes, and var-decl nodes. +For these node types in a statement context, the parent will be a +`js2-expr-stmt-node'. +Functions aren't included in the check." + (memq (js2-node-type node) js2-stmt-node-types)) + +(defun js2-mode-find-first-stmt (node) + "Search upward starting from NODE looking for a statement. +For purposes of this function, a `js2-function-node' counts." + (while (not (or (js2-stmt-node-p node) + (js2-function-node-p node))) + (setq node (js2-node-parent node))) + node) + +(defun js2-node-parent-stmt (node) + "Return the node's first ancestor that is a statement. +Returns nil if NODE is a `js2-ast-root'. Note that any expression +appearing in a statement context will have a parent that is a +`js2-expr-stmt-node' that will be returned by this function." + (let ((parent (js2-node-parent node))) + (if (or (null parent) + (js2-stmt-node-p parent) + (and (js2-function-node-p parent) + (eq (js2-function-node-form parent) 'FUNCTION_STATEMENT))) + parent + (js2-node-parent-stmt parent)))) + +;; In the Mozilla Rhino sources, Roshan James writes: +;; Does consistent-return analysis on the function body when strict mode is +;; enabled. +;; +;; function (x) { return (x+1) } +;; +;; is ok, but +;; +;; function (x) { if (x < 0) return (x+1); } +;; +;; is not because the function can potentially return a value when the +;; condition is satisfied and if not, the function does not explicitly +;; return a value. +;; +;; This extends to checking mismatches such as "return" and "return <value>" +;; used in the same function. Warnings are not emitted if inconsistent +;; returns exist in code that can be statically shown to be unreachable. +;; Ex. +;; function (x) { while (true) { ... if (..) { return value } ... } } +;; +;; emits no warning. However if the loop had a break statement, then a +;; warning would be emitted. +;; +;; The consistency analysis looks at control structures such as loops, ifs, +;; switch, try-catch-finally blocks, examines the reachable code paths and +;; warns the user about an inconsistent set of termination possibilities. +;; +;; These flags enumerate the possible ways a statement/function can +;; terminate. These flags are used by endCheck() and by the Parser to +;; detect inconsistent return usage. +;; +;; END_UNREACHED is reserved for code paths that are assumed to always be +;; able to execute (example: throw, continue) +;; +;; END_DROPS_OFF indicates if the statement can transfer control to the +;; next one. Statement such as return dont. A compound statement may have +;; some branch that drops off control to the next statement. +;; +;; END_RETURNS indicates that the statement can return with no value. +;; END_RETURNS_VALUE indicates that the statement can return a value. +;; +;; A compound statement such as +;; if (condition) { +;; return value; +;; } +;; Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck() + +(defconst js2-END_UNREACHED 0) +(defconst js2-END_DROPS_OFF 1) +(defconst js2-END_RETURNS 2) +(defconst js2-END_RETURNS_VALUE 4) +(defconst js2-END_YIELDS 8) + +(defun js2-has-consistent-return-usage (node) + "Check that every return usage in a function body is consistent. +Returns t if the function satisfies strict mode requirement." + (let ((n (js2-end-check node))) + ;; either it doesn't return a value in any branch... + (or (js2-flag-not-set-p n js2-END_RETURNS_VALUE) + ;; or it returns a value (or is unreached) at every branch + (js2-flag-not-set-p n (logior js2-END_DROPS_OFF + js2-END_RETURNS + js2-END_YIELDS))))) + +(defun js2-end-check-if (node) + "Ensure that return usage in then/else blocks is consistent. +If there is no else block, then the return statement can fall through. +Returns logical OR of END_* flags" + (let ((th (js2-if-node-then-part node)) + (el (js2-if-node-else-part node))) + (if (null th) + js2-END_UNREACHED + (logior (js2-end-check th) (if el + (js2-end-check el) + js2-END_DROPS_OFF))))) + +(defun js2-end-check-switch (node) + "Consistency of return statements is checked between the case statements. +If there is no default, then the switch can fall through. If there is a +default, we check to see if all code paths in the default return or if +there is a code path that can fall through. +Returns logical OR of END_* flags." + (let ((rv js2-END_UNREACHED) + default-case) + ;; examine the cases + (catch 'break + (dolist (c (js2-switch-node-cases node)) + (if (js2-case-node-expr c) + (js2-set-flag rv (js2-end-check-block c)) + (setq default-case c) + (throw 'break nil)))) + ;; we don't care how the cases drop into each other + (js2-clear-flag rv js2-END_DROPS_OFF) + ;; examine the default + (js2-set-flag rv (if default-case + (js2-end-check default-case) + js2-END_DROPS_OFF)) + rv)) + +(defun js2-end-check-try (node) + "If the block has a finally, return consistency is checked in the +finally block. If all code paths in the finally return, then the +returns in the try-catch blocks don't matter. If there is a code path +that does not return or if there is no finally block, the returns +of the try and catch blocks are checked for mismatch. +Returns logical OR of END_* flags." + (let ((finally (js2-try-node-finally-block node)) + rv) + ;; check the finally if it exists + (setq rv (if finally + (js2-end-check (js2-finally-node-body finally)) + js2-END_DROPS_OFF)) + ;; If the finally block always returns, then none of the returns + ;; in the try or catch blocks matter. + (when (js2-flag-set-p rv js2-END_DROPS_OFF) + (js2-clear-flag rv js2-END_DROPS_OFF) + ;; examine the try block + (js2-set-flag rv (js2-end-check (js2-try-node-try-block node))) + ;; check each catch block + (dolist (cb (js2-try-node-catch-clauses node)) + (js2-set-flag rv (js2-end-check cb)))) + rv)) + +(defun js2-end-check-loop (node) + "Return statement in the loop body must be consistent. +The default assumption for any kind of a loop is that it will eventually +terminate. The only exception is a loop with a constant true condition. +Code that follows such a loop is examined only if one can determine +statically that there is a break out of the loop. + + for(... ; ... ; ...) {} + for(... in ... ) {} + while(...) { } + do { } while(...) + +Returns logical OR of END_* flags." + (let ((rv (js2-end-check (js2-loop-node-body node))) + (condition (cond + ((js2-while-node-p node) + (js2-while-node-condition node)) + ((js2-do-node-p node) + (js2-do-node-condition node)) + ((js2-for-node-p node) + (js2-for-node-condition node))))) + + ;; check to see if the loop condition is always true + (if (and condition + (eq (js2-always-defined-boolean-p condition) 'ALWAYS_TRUE)) + (js2-clear-flag rv js2-END_DROPS_OFF)) + + ;; look for effect of breaks + (js2-set-flag rv (js2-node-get-prop node + 'CONTROL_BLOCK_PROP + js2-END_UNREACHED)) + rv)) + +(defun js2-end-check-block (node) + "A general block of code is examined statement by statement. +If any statement (even a compound one) returns in all branches, then +subsequent statements are not examined. +Returns logical OR of END_* flags." + (let* ((rv js2-END_DROPS_OFF) + (kids (js2-block-node-kids node)) + (n (car kids))) + ;; Check each statement. If the statement can continue onto the next + ;; one (i.e. END_DROPS_OFF is set), then check the next statement. + (while (and n (js2-flag-set-p rv js2-END_DROPS_OFF)) + (js2-clear-flag rv js2-END_DROPS_OFF) + (js2-set-flag rv (js2-end-check n)) + (setq kids (cdr kids) + n (car kids))) + rv)) + +(defun js2-end-check-label (node) + "A labeled statement implies that there may be a break to the label. +The function processes the labeled statement and then checks the +CONTROL_BLOCK_PROP property to see if there is ever a break to the +particular label. +Returns logical OR of END_* flags." + (let ((rv (js2-end-check (js2-labeled-stmt-node-stmt node)))) + (logior rv (js2-node-get-prop node + 'CONTROL_BLOCK_PROP + js2-END_UNREACHED)))) + +(defun js2-end-check-break (node) + "When a break is encountered annotate the statement being broken +out of by setting its CONTROL_BLOCK_PROP property. +Returns logical OR of END_* flags." + (and (js2-break-node-target node) + (js2-node-set-prop (js2-break-node-target node) + 'CONTROL_BLOCK_PROP + js2-END_DROPS_OFF)) + js2-END_UNREACHED) + +(defun js2-end-check (node) + "Examine the body of a function, doing a basic reachability analysis. +Returns a combination of flags END_* flags that indicate +how the function execution can terminate. These constitute only the +pessimistic set of termination conditions. It is possible that at +runtime certain code paths will never be actually taken. Hence this +analysis will flag errors in cases where there may not be errors. +Returns logical OR of END_* flags" + (let (kid) + (cond + ((js2-break-node-p node) + (js2-end-check-break node)) + ((js2-expr-stmt-node-p node) + (if (setq kid (js2-expr-stmt-node-expr node)) + (js2-end-check kid) + js2-END_DROPS_OFF)) + ((or (js2-continue-node-p node) + (js2-throw-node-p node)) + js2-END_UNREACHED) + ((js2-return-node-p node) + (if (setq kid (js2-return-node-retval node)) + js2-END_RETURNS_VALUE + js2-END_RETURNS)) + ((js2-loop-node-p node) + (js2-end-check-loop node)) + ((js2-switch-node-p node) + (js2-end-check-switch node)) + ((js2-labeled-stmt-node-p node) + (js2-end-check-label node)) + ((js2-if-node-p node) + (js2-end-check-if node)) + ((js2-try-node-p node) + (js2-end-check-try node)) + ((js2-block-node-p node) + (if (null (js2-block-node-kids node)) + js2-END_DROPS_OFF + (js2-end-check-block node))) + ((js2-yield-node-p node) + js2-END_YIELDS) + (t + js2-END_DROPS_OFF)))) + +(defun js2-always-defined-boolean-p (node) + "Check if NODE always evaluates to true or false in boolean context. +Returns `ALWAYS_TRUE', `ALWAYS_FALSE', or nil if it's neither always true +nor always false." + (let ((tt (js2-node-type node)) + num) + (cond + ((or (= tt js2-FALSE) (= tt js2-NULL)) + 'ALWAYS_FALSE) + ((= tt js2-TRUE) + 'ALWAYS_TRUE) + ((= tt js2-NUMBER) + (setq num (js2-number-node-num-value node)) + (if (and (not (eq num 0.0e+NaN)) + (not (zerop num))) + 'ALWAYS_TRUE + 'ALWAYS_FALSE)) + (t + nil)))) + +;;; Scanner -- a port of Mozilla Rhino's lexer. +;; Corresponds to Rhino files Token.java and TokenStream.java. + +(defvar js2-tokens nil + "List of all defined token names.") ; initialized in `js2-token-names' + +(defconst js2-token-names + (let* ((names (make-vector js2-num-tokens -1)) + (case-fold-search nil) ; only match js2-UPPER_CASE + (syms (apropos-internal "^js2-\\(?:[[:upper:]_]+\\)"))) + (cl-loop for sym in syms + for i from 0 + do + (unless (or (memq sym '(js2-EOF_CHAR js2-ERROR)) + (not (boundp sym))) + (aset names (symbol-value sym) ; code, e.g. 152 + (downcase + (substring (symbol-name sym) 4))) ; name, e.g. "let" + (push sym js2-tokens))) + names) + "Vector mapping int values to token string names, sans `js2-' prefix.") + +(defun js2-tt-name (tok) + "Return a string name for TOK, a token symbol or code. +Signals an error if it's not a recognized token." + (let ((code tok)) + (if (symbolp tok) + (setq code (symbol-value tok))) + (if (eq code -1) + "ERROR" + (if (and (numberp code) + (not (cl-minusp code)) + (< code js2-num-tokens)) + (aref js2-token-names code) + (error "Invalid token: %s" code))))) + +(defsubst js2-tt-sym (tok) + "Return symbol for TOK given its code, e.g. `js2-LP' for code 86." + (intern (js2-tt-name tok))) + +(defconst js2-token-codes + (let ((table (make-hash-table :test 'eq :size 256))) + (cl-loop for name across js2-token-names + for sym = (intern (concat "js2-" (upcase name))) + do + (puthash sym (symbol-value sym) table)) + ;; clean up a few that are "wrong" in Rhino's token codes + (puthash 'js2-DELETE js2-DELPROP table) + table) + "Hashtable mapping token type symbols to their bytecodes.") + +(defsubst js2-tt-code (sym) + "Return code for token symbol SYM, e.g. 86 for `js2-LP'." + (or (gethash sym js2-token-codes) + (error "Invalid token symbol: %s " sym))) ; signal code bug + +(defun js2-report-scan-error (msg &optional no-throw beg len) + (setf (js2-token-end (js2-current-token)) js2-ts-cursor) + (js2-report-error msg nil + (or beg (js2-current-token-beg)) + (or len (js2-current-token-len))) + (unless no-throw + (throw 'return js2-ERROR))) + +(defun js2-set-string-from-buffer (token) + "Set `string' and `end' slots for TOKEN, return the string." + (setf (js2-token-end token) js2-ts-cursor + (js2-token-string token) (js2-collect-string js2-ts-string-buffer))) + +;; TODO: could potentially avoid a lot of consing by allocating a +;; char buffer the way Rhino does. +(defsubst js2-add-to-string (c) + (push c js2-ts-string-buffer)) + +;; Note that when we "read" the end-of-file, we advance js2-ts-cursor +;; to (1+ (point-max)), which lets the scanner treat end-of-file like +;; any other character: when it's not part of the current token, we +;; unget it, allowing it to be read again by the following call. +(defsubst js2-unget-char () + (cl-decf js2-ts-cursor)) + +;; Rhino distinguishes \r and \n line endings. We don't need to +;; because we only scan from Emacs buffers, which always use \n. +(defun js2-get-char () + "Read and return the next character from the input buffer. +Increments `js2-ts-lineno' if the return value is a newline char. +Updates `js2-ts-cursor' to the point after the returned char. +Returns `js2-EOF_CHAR' if we hit the end of the buffer. +Also updates `js2-ts-hit-eof' and `js2-ts-line-start' as needed." + (let (c) + ;; check for end of buffer + (if (>= js2-ts-cursor (point-max)) + (setq js2-ts-hit-eof t + js2-ts-cursor (1+ js2-ts-cursor) + c js2-EOF_CHAR) ; return value + ;; otherwise read next char + (setq c (char-before (cl-incf js2-ts-cursor))) + ;; if we read a newline, update counters + (if (= c ?\n) + (setq js2-ts-line-start js2-ts-cursor + js2-ts-lineno (1+ js2-ts-lineno))) + ;; TODO: skip over format characters + c))) + +(defun js2-read-unicode-escape () + "Read a \\uNNNN sequence from the input. +Assumes the ?\\ and ?u have already been read. +Returns the unicode character, or nil if it wasn't a valid character. +Doesn't change the values of any scanner variables." + ;; I really wish I knew a better way to do this, but I can't + ;; find the Emacs function that takes a 16-bit int and converts + ;; it to a Unicode/utf-8 character. So I basically eval it with (read). + ;; Have to first check that it's 4 hex characters or it may stop + ;; the read early. + (ignore-errors + (let ((s (buffer-substring-no-properties js2-ts-cursor + (+ 4 js2-ts-cursor)))) + (if (string-match "[0-9a-fA-F]\\{4\\}" s) + (read (concat "?\\u" s)))))) + +(defun js2-match-char (test) + "Consume and return next character if it matches TEST, a character. +Returns nil and consumes nothing if TEST is not the next character." + (let ((c (js2-get-char))) + (if (eq c test) + t + (js2-unget-char) + nil))) + +(defun js2-peek-char () + (prog1 + (js2-get-char) + (js2-unget-char))) + +(defun js2-identifier-start-p (c) + "Is C a valid start to an ES5 Identifier? +See http://es5.github.io/#x7.6" + (or + (memq c '(?$ ?_)) + (memq (get-char-code-property c 'general-category) + ;; Letters + '(Lu Ll Lt Lm Lo Nl)))) + +(defun js2-identifier-part-p (c) + "Is C a valid part of an ES5 Identifier? +See http://es5.github.io/#x7.6" + (or + (memq c '(?$ ?_ ?\u200c ?\u200d)) + (memq (get-char-code-property c 'general-category) + '(;; Letters + Lu Ll Lt Lm Lo Nl + ;; Combining Marks + Mn Mc + ;; Digits + Nd + ;; Connector Punctuation + Pc)))) + +(defun js2-alpha-p (c) + (cond ((and (<= ?A c) (<= c ?Z)) t) + ((and (<= ?a c) (<= c ?z)) t) + (t nil))) + +(defsubst js2-digit-p (c) + (and (<= ?0 c) (<= c ?9))) + +(defun js2-js-space-p (c) + (if (<= c 127) + (memq c '(#x20 #x9 #xB #xC #xD)) + (or + (eq c #xA0) + ;; TODO: change this nil to check for Unicode space character + nil))) + +(defconst js2-eol-chars (list js2-EOF_CHAR ?\n ?\r)) + +(defun js2-skip-line () + "Skip to end of line." + (while (not (memq (js2-get-char) js2-eol-chars))) + (js2-unget-char) + (setf (js2-token-end (js2-current-token)) js2-ts-cursor)) + +(defun js2-init-scanner (&optional buf line) + "Create token stream for BUF starting on LINE. +BUF defaults to `current-buffer' and LINE defaults to 1. + +A buffer can only have one scanner active at a time, which yields +dramatically simpler code than using a defstruct. If you need to +have simultaneous scanners in a buffer, copy the regions to scan +into temp buffers." + (with-current-buffer (or buf (current-buffer)) + (setq js2-ts-dirty-line nil + js2-ts-hit-eof nil + js2-ts-line-start 0 + js2-ts-lineno (or line 1) + js2-ts-line-end-char -1 + js2-ts-cursor (point-min) + js2-ti-tokens (make-vector js2-ti-ntokens nil) + js2-ti-tokens-cursor 0 + js2-ti-lookahead 0 + js2-ts-is-xml-attribute nil + js2-ts-xml-is-tag-content nil + js2-ts-xml-open-tags-count 0 + js2-ts-string-buffer nil))) + +;; This function uses the cached op, string and number fields in +;; TokenStream; if getToken has been called since the passed token +;; was scanned, the op or string printed may be incorrect. +(defun js2-token-to-string (token) + ;; Not sure where this function is used in Rhino. Not tested. + (if (not js2-debug-print-trees) + "" + (let ((name (js2-tt-name token))) + (cond + ((memq token '(js2-STRING js2-REGEXP js2-NAME + js2-TEMPLATE_HEAD js2-NO_SUBS_TEMPLATE)) + (concat name " `" (js2-current-token-string) "'")) + ((eq token js2-NUMBER) + (format "NUMBER %g" (js2-token-number (js2-current-token)))) + (t + name))))) + +(defconst js2-keywords + '(break + case catch class const continue + debugger default delete do + else extends export + false finally for function + if in instanceof import + let + new null + return + super switch + this throw true try typeof + var void + while with + yield)) + +;; Token names aren't exactly the same as the keywords, unfortunately. +;; E.g. delete is js2-DELPROP. +(defconst js2-kwd-tokens + (let ((table (make-vector js2-num-tokens nil)) + (tokens + (list js2-BREAK + js2-CASE js2-CATCH js2-CLASS js2-CONST js2-CONTINUE + js2-DEBUGGER js2-DEFAULT js2-DELPROP js2-DO + js2-ELSE js2-EXPORT + js2-ELSE js2-EXTENDS js2-EXPORT + js2-FALSE js2-FINALLY js2-FOR js2-FUNCTION + js2-IF js2-IN js2-INSTANCEOF js2-IMPORT + js2-LET + js2-NEW js2-NULL + js2-RETURN + js2-SUPER js2-SWITCH + js2-THIS js2-THROW js2-TRUE js2-TRY js2-TYPEOF + js2-VAR + js2-WHILE js2-WITH + js2-YIELD))) + (dolist (i tokens) + (aset table i 'font-lock-keyword-face)) + (aset table js2-STRING 'font-lock-string-face) + (aset table js2-REGEXP 'font-lock-string-face) + (aset table js2-NO_SUBS_TEMPLATE 'font-lock-string-face) + (aset table js2-TEMPLATE_HEAD 'font-lock-string-face) + (aset table js2-COMMENT 'font-lock-comment-face) + (aset table js2-THIS 'font-lock-builtin-face) + (aset table js2-SUPER 'font-lock-builtin-face) + (aset table js2-VOID 'font-lock-constant-face) + (aset table js2-NULL 'font-lock-constant-face) + (aset table js2-TRUE 'font-lock-constant-face) + (aset table js2-FALSE 'font-lock-constant-face) + (aset table js2-NOT 'font-lock-negation-char-face) + table) + "Vector whose values are non-nil for tokens that are keywords. +The values are default faces to use for highlighting the keywords.") + +;; FIXME: Support strict mode-only future reserved words, after we know +;; which parts scopes are in strict mode, and which are not. +(defconst js2-reserved-words '(class enum export extends import static super) + "Future reserved keywords in ECMAScript 5.1.") + +(defconst js2-keyword-names + (let ((table (make-hash-table :test 'equal))) + (cl-loop for k in js2-keywords + do (puthash + (symbol-name k) ; instanceof + (intern (concat "js2-" + (upcase (symbol-name k)))) ; js2-INSTANCEOF + table)) + table) + "JavaScript keywords by name, mapped to their symbols.") + +(defconst js2-reserved-word-names + (let ((table (make-hash-table :test 'equal))) + (cl-loop for k in js2-reserved-words + do + (puthash (symbol-name k) 'js2-RESERVED table)) + table) + "JavaScript reserved words by name, mapped to `js2-RESERVED'.") + +(defun js2-collect-string (buf) + "Convert BUF, a list of chars, to a string. +Reverses BUF before converting." + (if buf + (apply #'string (nreverse buf)) + "")) + +(defun js2-string-to-keyword (s) + "Return token for S, a string, if S is a keyword or reserved word. +Returns a symbol such as `js2-BREAK', or nil if not keyword/reserved." + (or (gethash s js2-keyword-names) + (gethash s js2-reserved-word-names))) + +(defsubst js2-ts-set-char-token-bounds (token) + "Used when next token is one character." + (setf (js2-token-beg token) (1- js2-ts-cursor) + (js2-token-end token) js2-ts-cursor)) + +(defsubst js2-ts-return (token type) + "Update the `end' and `type' slots of TOKEN, +then throw `return' with value TYPE." + (setf (js2-token-end token) js2-ts-cursor + (js2-token-type token) type) + (throw 'return type)) + +(defun js2-x-digit-to-int (c accumulator) + "Build up a hex number. +If C is a hexadecimal digit, return ACCUMULATOR * 16 plus +corresponding number. Otherwise return -1." + (catch 'return + (catch 'check + ;; Use 0..9 < A..Z < a..z + (cond + ((<= c ?9) + (cl-decf c ?0) + (if (<= 0 c) + (throw 'check nil))) + ((<= c ?F) + (when (<= ?A c) + (cl-decf c (- ?A 10)) + (throw 'check nil))) + ((<= c ?f) + (when (<= ?a c) + (cl-decf c (- ?a 10)) + (throw 'check nil)))) + (throw 'return -1)) + (logior c (lsh accumulator 4)))) + +(defun js2-get-token (&optional modifier) + "If `js2-ti-lookahead' is zero, call scanner to get new token. +Otherwise, move `js2-ti-tokens-cursor' and return the type of +next saved token. + +This function will not return a newline (js2-EOL) - instead, it +gobbles newlines until it finds a non-newline token. Call +`js2-peek-token-or-eol' when you care about newlines. + +This function will also not return a js2-COMMENT. Instead, it +records comments found in `js2-scanned-comments'. If the token +returned by this function immediately follows a jsdoc comment, +the token is flagged as such." + (if (zerop js2-ti-lookahead) + (js2-get-token-internal modifier) + (cl-decf js2-ti-lookahead) + (setq js2-ti-tokens-cursor (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens)) + (let ((tt (js2-current-token-type))) + (cl-assert (not (= tt js2-EOL))) + tt))) + +(defun js2-unget-token () + (cl-assert (< js2-ti-lookahead js2-ti-max-lookahead)) + (cl-incf js2-ti-lookahead) + (setq js2-ti-tokens-cursor (mod (1- js2-ti-tokens-cursor) js2-ti-ntokens))) + +(defun js2-get-token-internal (modifier) + (let* ((token (js2-get-token-internal-1 modifier)) ; call scanner + (tt (js2-token-type token)) + saw-eol + face) + ;; process comments + (while (or (= tt js2-EOL) (= tt js2-COMMENT)) + (if (= tt js2-EOL) + (setq saw-eol t) + (setq saw-eol nil) + (when js2-record-comments + (js2-record-comment token))) + (setq js2-ti-tokens-cursor (mod (1- js2-ti-tokens-cursor) js2-ti-ntokens)) + (setq token (js2-get-token-internal-1 modifier) ; call scanner again + tt (js2-token-type token))) + + (when saw-eol + (setf (js2-token-follows-eol-p token) t)) + + ;; perform lexical fontification as soon as token is scanned + (when js2-parse-ide-mode + (cond + ((cl-minusp tt) + (js2-record-face 'js2-error token)) + ((setq face (aref js2-kwd-tokens tt)) + (js2-record-face face token)) + ((and (= tt js2-NAME) + (equal (js2-token-string token) "undefined")) + (js2-record-face 'font-lock-constant-face token)))) + tt)) + +(defsubst js2-string-to-number (str base) + ;; TODO: Maybe port ScriptRuntime.stringToNumber. + (condition-case nil + (string-to-number str base) + (overflow-error -1))) + +(defun js2-get-token-internal-1 (modifier) + "Return next JavaScript token type, an int such as js2-RETURN. +During operation, creates an instance of `js2-token' struct, sets +its relevant fields and puts it into `js2-ti-tokens'." + (let (identifier-start + is-unicode-escape-start c + contains-escape escape-val str result base + look-for-slash continue tt legacy-octal + (token (js2-new-token 0))) + (setq + tt + (catch 'return + (when (eq modifier 'TEMPLATE_TAIL) + (setf (js2-token-beg token) (1- js2-ts-cursor)) + (throw 'return (js2-get-string-or-template-token ?` token))) + (while t + ;; Eat whitespace, possibly sensitive to newlines. + (setq continue t) + (while continue + (setq c (js2-get-char)) + (cond + ((eq c js2-EOF_CHAR) + (js2-unget-char) + (js2-ts-set-char-token-bounds token) + (throw 'return js2-EOF)) + ((eq c ?\n) + (js2-ts-set-char-token-bounds token) + (setq js2-ts-dirty-line nil) + (throw 'return js2-EOL)) + ((not (js2-js-space-p c)) + (if (/= c ?-) ; in case end of HTML comment + (setq js2-ts-dirty-line t)) + (setq continue nil)))) + ;; Assume the token will be 1 char - fixed up below. + (js2-ts-set-char-token-bounds token) + (when (eq c ?@) + (throw 'return js2-XMLATTR)) + ;; identifier/keyword/instanceof? + ;; watch out for starting with a <backslash> + (cond + ((eq c ?\\) + (setq c (js2-get-char)) + (if (eq c ?u) + (setq identifier-start t + is-unicode-escape-start t + js2-ts-string-buffer nil) + (setq identifier-start nil) + (js2-unget-char) + (setq c ?\\))) + (t + (when (setq identifier-start (js2-identifier-start-p c)) + (setq js2-ts-string-buffer nil) + (js2-add-to-string c)))) + (when identifier-start + (setq contains-escape is-unicode-escape-start) + (catch 'break + (while t + (if is-unicode-escape-start + ;; strictly speaking we should probably push-back + ;; all the bad characters if the <backslash>uXXXX + ;; sequence is malformed. But since there isn't a + ;; correct context(is there?) for a bad Unicode + ;; escape sequence in an identifier, we can report + ;; an error here. + (progn + (setq escape-val 0) + (dotimes (_ 4) + (setq c (js2-get-char) + escape-val (js2-x-digit-to-int c escape-val)) + ;; Next check takes care of c < 0 and bad escape + (if (cl-minusp escape-val) + (throw 'break nil))) + (if (cl-minusp escape-val) + (js2-report-scan-error "msg.invalid.escape" t)) + (js2-add-to-string escape-val) + (setq is-unicode-escape-start nil)) + (setq c (js2-get-char)) + (cond + ((eq c ?\\) + (setq c (js2-get-char)) + (if (eq c ?u) + (setq is-unicode-escape-start t + contains-escape t) + (js2-report-scan-error "msg.illegal.character" t))) + (t + (if (or (eq c js2-EOF_CHAR) + (not (js2-identifier-part-p c))) + (throw 'break nil)) + (js2-add-to-string c)))))) + (js2-unget-char) + (setf str (js2-collect-string js2-ts-string-buffer) + (js2-token-end token) js2-ts-cursor) + ;; FIXME: Invalid in ES5 and ES6, see + ;; https://bugzilla.mozilla.org/show_bug.cgi?id=694360 + ;; Probably should just drop this conditional. + (unless contains-escape + ;; OPT we shouldn't have to make a string (object!) to + ;; check if it's a keyword. + ;; Return the corresponding token if it's a keyword + (when (and (not (eq modifier 'KEYWORD_IS_NAME)) + (setq result (js2-string-to-keyword str))) + (if (and (< js2-language-version 170) + (memq result '(js2-LET js2-YIELD))) + ;; LET and YIELD are tokens only in 1.7 and later + (setq result 'js2-NAME)) + (when (eq result 'js2-RESERVED) + (setf (js2-token-string token) str)) + (throw 'return (js2-tt-code result)))) + ;; If we want to intern these as Rhino does, just use (intern str) + (setf (js2-token-string token) str) + (throw 'return js2-NAME)) ; end identifier/kwd check + ;; is it a number? + (when (or (js2-digit-p c) + (and (eq c ?.) (js2-digit-p (js2-peek-char)))) + (setq js2-ts-string-buffer nil + base 10) + (when (eq c ?0) + (setq c (js2-get-char)) + (cond + ((or (eq c ?x) (eq c ?X)) + (setq base 16) + (setq c (js2-get-char))) + ((and (or (eq c ?b) (eq c ?B)) + (>= js2-language-version 200)) + (setq base 2) + (setq c (js2-get-char))) + ((and (or (eq c ?o) (eq c ?O)) + (>= js2-language-version 200)) + (setq base 8) + (setq legacy-octal nil) + (setq c (js2-get-char))) + ((js2-digit-p c) + (setq base 'maybe-8)) + (t + (js2-add-to-string ?0)))) + (cond + ((eq base 16) + (if (> 0 (js2-x-digit-to-int c 0)) + (js2-report-scan-error "msg.missing.hex.digits") + (while (<= 0 (js2-x-digit-to-int c 0)) + (js2-add-to-string c) + (setq c (js2-get-char))))) + ((eq base 2) + (if (not (memq c '(?0 ?1))) + (js2-report-scan-error "msg.missing.binary.digits") + (while (memq c '(?0 ?1)) + (js2-add-to-string c) + (setq c (js2-get-char))))) + ((eq base 8) + (if (or (> ?0 c) (< ?7 c)) + (js2-report-scan-error "msg.missing.octal.digits") + (while (and (<= ?0 c) (>= ?7 c)) + (js2-add-to-string c) + (setq c (js2-get-char))))) + (t + (while (and (<= ?0 c) (<= c ?9)) + ;; We permit 08 and 09 as decimal numbers, which + ;; makes our behavior a superset of the ECMA + ;; numeric grammar. We might not always be so + ;; permissive, so we warn about it. + (when (and (eq base 'maybe-8) (>= c ?8)) + (js2-report-warning "msg.bad.octal.literal" + (if (eq c ?8) "8" "9")) + (setq base 10)) + (js2-add-to-string c) + (setq c (js2-get-char))) + (when (eq base 'maybe-8) + (setq base 8 + legacy-octal t)))) + (when (and (eq base 10) (memq c '(?. ?e ?E))) + (when (eq c ?.) + (cl-loop do + (js2-add-to-string c) + (setq c (js2-get-char)) + while (js2-digit-p c))) + (when (memq c '(?e ?E)) + (js2-add-to-string c) + (setq c (js2-get-char)) + (when (memq c '(?+ ?-)) + (js2-add-to-string c) + (setq c (js2-get-char))) + (unless (js2-digit-p c) + (js2-report-scan-error "msg.missing.exponent" t)) + (cl-loop do + (js2-add-to-string c) + (setq c (js2-get-char)) + while (js2-digit-p c)))) + (js2-unget-char) + (let ((str (js2-set-string-from-buffer token))) + (setf (js2-token-number token) (js2-string-to-number str base) + (js2-token-number-base token) base + (js2-token-number-legacy-octal-p token) (and (= base 8) legacy-octal))) + (throw 'return js2-NUMBER)) + ;; is it a string? + (when (or (memq c '(?\" ?\')) + (and (>= js2-language-version 200) + (= c ?`))) + (throw 'return + (js2-get-string-or-template-token c token))) + (js2-ts-return token + (cl-case c + (?\; + (throw 'return js2-SEMI)) + (?\[ + (throw 'return js2-LB)) + (?\] + (throw 'return js2-RB)) + (?{ + (throw 'return js2-LC)) + (?} + (throw 'return js2-RC)) + (?\( + (throw 'return js2-LP)) + (?\) + (throw 'return js2-RP)) + (?, + (throw 'return js2-COMMA)) + (?? + (throw 'return js2-HOOK)) + (?: + (if (js2-match-char ?:) + js2-COLONCOLON + (throw 'return js2-COLON))) + (?. + (if (js2-match-char ?.) + (if (js2-match-char ?.) + js2-TRIPLEDOT js2-DOTDOT) + (if (js2-match-char ?\() + js2-DOTQUERY + (throw 'return js2-DOT)))) + (?| + (if (js2-match-char ?|) + (throw 'return js2-OR) + (if (js2-match-char ?=) + js2-ASSIGN_BITOR + (throw 'return js2-BITOR)))) + (?^ + (if (js2-match-char ?=) + js2-ASSIGN_BITOR + (throw 'return js2-BITXOR))) + (?& + (if (js2-match-char ?&) + (throw 'return js2-AND) + (if (js2-match-char ?=) + js2-ASSIGN_BITAND + (throw 'return js2-BITAND)))) + (?= + (if (js2-match-char ?=) + (if (js2-match-char ?=) + js2-SHEQ + (throw 'return js2-EQ)) + (if (js2-match-char ?>) + (js2-ts-return token js2-ARROW) + (throw 'return js2-ASSIGN)))) + (?! + (if (js2-match-char ?=) + (if (js2-match-char ?=) + js2-SHNE + js2-NE) + (throw 'return js2-NOT))) + (?< + ;; NB:treat HTML begin-comment as comment-till-eol + (when (js2-match-char ?!) + (when (js2-match-char ?-) + (when (js2-match-char ?-) + (js2-skip-line) + (setf (js2-token-comment-type (js2-current-token)) 'html) + (throw 'return js2-COMMENT))) + (js2-unget-char)) + (if (js2-match-char ?<) + (if (js2-match-char ?=) + js2-ASSIGN_LSH + js2-LSH) + (if (js2-match-char ?=) + js2-LE + (throw 'return js2-LT)))) + (?> + (if (js2-match-char ?>) + (if (js2-match-char ?>) + (if (js2-match-char ?=) + js2-ASSIGN_URSH + js2-URSH) + (if (js2-match-char ?=) + js2-ASSIGN_RSH + js2-RSH)) + (if (js2-match-char ?=) + js2-GE + (throw 'return js2-GT)))) + (?* + (if (js2-match-char ?=) + js2-ASSIGN_MUL + (if (js2-match-char ?*) + (if (js2-match-char ?=) + js2-ASSIGN_EXPON + js2-EXPON) + (throw 'return js2-MUL)))) + (?/ + ;; is it a // comment? + (when (js2-match-char ?/) + (setf (js2-token-beg token) (- js2-ts-cursor 2)) + (js2-skip-line) + (setf (js2-token-comment-type token) 'line) + ;; include newline so highlighting goes to end of + ;; window, if there actually is a newline; if we + ;; hit eof, then implicitly there isn't + (unless js2-ts-hit-eof + (cl-incf (js2-token-end token))) + (throw 'return js2-COMMENT)) + ;; is it a /* comment? + (when (js2-match-char ?*) + (setf look-for-slash nil + (js2-token-beg token) (- js2-ts-cursor 2) + (js2-token-comment-type token) + (if (js2-match-char ?*) + (progn + (setq look-for-slash t) + 'jsdoc) + 'block)) + (while t + (setq c (js2-get-char)) + (cond + ((eq c js2-EOF_CHAR) + (setf (js2-token-end token) (1- js2-ts-cursor)) + (js2-report-error "msg.unterminated.comment") + (throw 'return js2-COMMENT)) + ((eq c ?*) + (setq look-for-slash t)) + ((eq c ?/) + (if look-for-slash + (js2-ts-return token js2-COMMENT))) + (t + (setf look-for-slash nil + (js2-token-end token) js2-ts-cursor))))) + (if (js2-match-char ?=) + js2-ASSIGN_DIV + (throw 'return js2-DIV))) + (?# + (when js2-skip-preprocessor-directives + (js2-skip-line) + (setf (js2-token-comment-type token) 'preprocessor + (js2-token-end token) js2-ts-cursor) + (throw 'return js2-COMMENT)) + (throw 'return js2-ERROR)) + (?% + (if (js2-match-char ?=) + js2-ASSIGN_MOD + (throw 'return js2-MOD))) + (?~ + (throw 'return js2-BITNOT)) + (?+ + (if (js2-match-char ?=) + js2-ASSIGN_ADD + (if (js2-match-char ?+) + js2-INC + (throw 'return js2-ADD)))) + (?- + (cond + ((js2-match-char ?=) + (setq c js2-ASSIGN_SUB)) + ((js2-match-char ?-) + (unless js2-ts-dirty-line + ;; treat HTML end-comment after possible whitespace + ;; after line start as comment-until-eol + (when (js2-match-char ?>) + (js2-skip-line) + (setf (js2-token-comment-type (js2-current-token)) 'html) + (throw 'return js2-COMMENT))) + (setq c js2-DEC)) + (t + (setq c js2-SUB))) + (setq js2-ts-dirty-line t) + c) + (otherwise + (js2-report-scan-error "msg.illegal.character"))))))) + (setf (js2-token-type token) tt) + token)) + +(defun js2-get-string-or-template-token (quote-char token) + ;; We attempt to accumulate a string the fast way, by + ;; building it directly out of the reader. But if there + ;; are any escaped characters in the string, we revert to + ;; building it out of a string buffer. + (let ((c (js2-get-char)) + js2-ts-string-buffer + nc c1 val escape-val) + (catch 'break + (while (/= c quote-char) + (catch 'continue + (when (eq c js2-EOF_CHAR) + (js2-unget-char) + (js2-report-error "msg.unterminated.string.lit") + (throw 'break nil)) + (when (and (eq c ?\n) (not (eq quote-char ?`))) + (js2-unget-char) + (js2-report-error "msg.unterminated.string.lit") + (throw 'break nil)) + (when (eq c ?\\) + ;; We've hit an escaped character + (setq c (js2-get-char)) + (cl-case c + (?b (setq c ?\b)) + (?f (setq c ?\f)) + (?n (setq c ?\n)) + (?r (setq c ?\r)) + (?t (setq c ?\t)) + (?v (setq c ?\v)) + (?u + (setq c1 (js2-read-unicode-escape)) + (if js2-parse-ide-mode + (if c1 + (progn + ;; just copy the string in IDE-mode + (js2-add-to-string ?\\) + (js2-add-to-string ?u) + (dotimes (_ 3) + (js2-add-to-string (js2-get-char))) + (setq c (js2-get-char))) ; added at end of loop + ;; flag it as an invalid escape + (js2-report-warning "msg.invalid.escape" + nil (- js2-ts-cursor 2) 6)) + ;; Get 4 hex digits; if the u escape is not + ;; followed by 4 hex digits, use 'u' + the + ;; literal character sequence that follows. + (js2-add-to-string ?u) + (setq escape-val 0) + (dotimes (_ 4) + (setq c (js2-get-char) + escape-val (js2-x-digit-to-int c escape-val)) + (if (cl-minusp escape-val) + (throw 'continue nil)) + (js2-add-to-string c)) + ;; prepare for replace of stored 'u' sequence by escape value + (setq js2-ts-string-buffer (nthcdr 5 js2-ts-string-buffer) + c escape-val))) + (?x + ;; Get 2 hex digits, defaulting to 'x'+literal + ;; sequence, as above. + (setq c (js2-get-char) + escape-val (js2-x-digit-to-int c 0)) + (if (cl-minusp escape-val) + (progn + (js2-add-to-string ?x) + (throw 'continue nil)) + (setq c1 c + c (js2-get-char) + escape-val (js2-x-digit-to-int c escape-val)) + (if (cl-minusp escape-val) + (progn + (js2-add-to-string ?x) + (js2-add-to-string c1) + (throw 'continue nil)) + ;; got 2 hex digits + (setq c escape-val)))) + (?\n + ;; Remove line terminator after escape to follow + ;; SpiderMonkey and C/C++ + (setq c (js2-get-char)) + (throw 'continue nil)) + (t + (when (and (<= ?0 c) (< c ?8)) + (setq val (- c ?0) + c (js2-get-char)) + (when (and (<= ?0 c) (< c ?8)) + (setq val (- (+ (* 8 val) c) ?0) + c (js2-get-char)) + (when (and (<= ?0 c) + (< c ?8) + (< val #o37)) + ;; c is 3rd char of octal sequence only + ;; if the resulting val <= 0377 + (setq val (- (+ (* 8 val) c) ?0) + c (js2-get-char)))) + (js2-unget-char) + (setq c val))))) + (when (and (eq quote-char ?`) (eq c ?$)) + (when (eq (setq nc (js2-get-char)) ?\{) + (throw 'break nil)) + (js2-unget-char)) + (js2-add-to-string c) + (setq c (js2-get-char))))) + (js2-set-string-from-buffer token) + (if (not (eq quote-char ?`)) + js2-STRING + (if (and (eq c ?$) (eq nc ?\{)) + js2-TEMPLATE_HEAD + js2-NO_SUBS_TEMPLATE)))) + +(defun js2-read-regexp (start-tt start-pos) + "Called by parser when it gets / or /= in literal context." + (let (c err + in-class ; inside a '[' .. ']' character-class + flags + (continue t) + (token (js2-new-token 0))) + (js2-record-text-property start-pos (1+ start-pos) + 'syntax-table (string-to-syntax "\"/")) + (setq js2-ts-string-buffer nil) + (if (eq start-tt js2-ASSIGN_DIV) + ;; mis-scanned /= + (js2-add-to-string ?=) + (if (not (eq start-tt js2-DIV)) + (error "failed assertion"))) + (while (and (not err) + (or (/= (setq c (js2-get-char)) ?/) + in-class)) + (cond + ((or (= c ?\n) + (= c js2-EOF_CHAR)) + (setf (js2-token-end token) (1- js2-ts-cursor) + err t + (js2-token-string token) (js2-collect-string js2-ts-string-buffer)) + (js2-report-error "msg.unterminated.re.lit")) + (t (cond + ((= c ?\\) + (js2-add-to-string c) + (setq c (js2-get-char))) + ((= c ?\[) + (setq in-class t)) + ((= c ?\]) + (setq in-class nil))) + (js2-add-to-string c)))) + (unless err + (js2-record-text-property (1- js2-ts-cursor) js2-ts-cursor + 'syntax-table (string-to-syntax "\"/")) + (while continue + (cond + ((js2-match-char ?g) + (push ?g flags)) + ((js2-match-char ?i) + (push ?i flags)) + ((js2-match-char ?m) + (push ?m flags)) + ((and (js2-match-char ?u) + (>= js2-language-version 200)) + (push ?u flags)) + ((and (js2-match-char ?y) + (>= js2-language-version 200)) + (push ?y flags)) + (t + (setq continue nil)))) + (if (js2-alpha-p (js2-peek-char)) + (js2-report-scan-error "msg.invalid.re.flag" t + js2-ts-cursor 1)) + (js2-set-string-from-buffer token)) + (js2-collect-string flags))) + +(defun js2-get-first-xml-token () + (setq js2-ts-xml-open-tags-count 0 + js2-ts-is-xml-attribute nil + js2-ts-xml-is-tag-content nil) + (js2-unget-char) + (js2-get-next-xml-token)) + +(defun js2-xml-discard-string (token) + "Throw away the string in progress and flag an XML parse error." + (setf js2-ts-string-buffer nil + (js2-token-string token) nil) + (js2-report-scan-error "msg.XML.bad.form" t)) + +(defun js2-get-next-xml-token () + (setq js2-ts-string-buffer nil) ; for recording the XML + (let ((token (js2-new-token 0)) + c result) + (setq result + (catch 'return + (while t + (setq c (js2-get-char)) + (cond + ((= c js2-EOF_CHAR) + (throw 'return js2-ERROR)) + (js2-ts-xml-is-tag-content + (cl-case c + (?> + (js2-add-to-string c) + (setq js2-ts-xml-is-tag-content nil + js2-ts-is-xml-attribute nil)) + (?/ + (js2-add-to-string c) + (when (eq ?> (js2-peek-char)) + (setq c (js2-get-char)) + (js2-add-to-string c) + (setq js2-ts-xml-is-tag-content nil) + (cl-decf js2-ts-xml-open-tags-count))) + (?{ + (js2-unget-char) + (js2-set-string-from-buffer token) + (throw 'return js2-XML)) + ((?\' ?\") + (js2-add-to-string c) + (unless (js2-read-quoted-string c token) + (throw 'return js2-ERROR))) + (?= + (js2-add-to-string c) + (setq js2-ts-is-xml-attribute t)) + ((? ?\t ?\r ?\n) + (js2-add-to-string c)) + (t + (js2-add-to-string c) + (setq js2-ts-is-xml-attribute nil))) + (when (and (not js2-ts-xml-is-tag-content) + (zerop js2-ts-xml-open-tags-count)) + (js2-set-string-from-buffer token) + (throw 'return js2-XMLEND))) + (t + ;; else not tag content + (cl-case c + (?< + (js2-add-to-string c) + (setq c (js2-peek-char)) + (cl-case c + (?! + (setq c (js2-get-char)) ;; skip ! + (js2-add-to-string c) + (setq c (js2-peek-char)) + (cl-case c + (?- + (setq c (js2-get-char)) ;; skip - + (js2-add-to-string c) + (if (eq c ?-) + (progn + (js2-add-to-string c) + (unless (js2-read-xml-comment token) + (throw 'return js2-ERROR))) + (js2-xml-discard-string token) + (throw 'return js2-ERROR))) + (?\[ + (setq c (js2-get-char)) ;; skip [ + (js2-add-to-string c) + (if (and (= (js2-get-char) ?C) + (= (js2-get-char) ?D) + (= (js2-get-char) ?A) + (= (js2-get-char) ?T) + (= (js2-get-char) ?A) + (= (js2-get-char) ?\[)) + (progn + (js2-add-to-string ?C) + (js2-add-to-string ?D) + (js2-add-to-string ?A) + (js2-add-to-string ?T) + (js2-add-to-string ?A) + (js2-add-to-string ?\[) + (unless (js2-read-cdata token) + (throw 'return js2-ERROR))) + (js2-xml-discard-string token) + (throw 'return js2-ERROR))) + (t + (unless (js2-read-entity token) + (throw 'return js2-ERROR)))) + ;; Allow bare CDATA section, e.g.: + ;; let xml = <![CDATA[ foo bar baz ]]>; + (when (zerop js2-ts-xml-open-tags-count) + (throw 'return js2-XMLEND))) + (?? + (setq c (js2-get-char)) ;; skip ? + (js2-add-to-string c) + (unless (js2-read-PI token) + (throw 'return js2-ERROR))) + (?/ + ;; end tag + (setq c (js2-get-char)) ;; skip / + (js2-add-to-string c) + (when (zerop js2-ts-xml-open-tags-count) + (js2-xml-discard-string token) + (throw 'return js2-ERROR)) + (setq js2-ts-xml-is-tag-content t) + (cl-decf js2-ts-xml-open-tags-count)) + (t + ;; start tag + (setq js2-ts-xml-is-tag-content t) + (cl-incf js2-ts-xml-open-tags-count)))) + (?{ + (js2-unget-char) + (js2-set-string-from-buffer token) + (throw 'return js2-XML)) + (t + (js2-add-to-string c)))))))) + (setf (js2-token-end token) js2-ts-cursor) + (setf (js2-token-type token) result) + result)) + +(defun js2-read-quoted-string (quote token) + (let (c) + (catch 'return + (while (/= (setq c (js2-get-char)) js2-EOF_CHAR) + (js2-add-to-string c) + (if (eq c quote) + (throw 'return t))) + (js2-xml-discard-string token) ;; throw away string in progress + nil))) + +(defun js2-read-xml-comment (token) + (let ((c (js2-get-char))) + (catch 'return + (while (/= c js2-EOF_CHAR) + (catch 'continue + (js2-add-to-string c) + (when (and (eq c ?-) (eq ?- (js2-peek-char))) + (setq c (js2-get-char)) + (js2-add-to-string c) + (if (eq (js2-peek-char) ?>) + (progn + (setq c (js2-get-char)) ;; skip > + (js2-add-to-string c) + (throw 'return t)) + (throw 'continue nil))) + (setq c (js2-get-char)))) + (js2-xml-discard-string token) + nil))) + +(defun js2-read-cdata (token) + (let ((c (js2-get-char))) + (catch 'return + (while (/= c js2-EOF_CHAR) + (catch 'continue + (js2-add-to-string c) + (when (and (eq c ?\]) (eq (js2-peek-char) ?\])) + (setq c (js2-get-char)) + (js2-add-to-string c) + (if (eq (js2-peek-char) ?>) + (progn + (setq c (js2-get-char)) ;; Skip > + (js2-add-to-string c) + (throw 'return t)) + (throw 'continue nil))) + (setq c (js2-get-char)))) + (js2-xml-discard-string token) + nil))) + +(defun js2-read-entity (token) + (let ((decl-tags 1) + c) + (catch 'return + (while (/= js2-EOF_CHAR (setq c (js2-get-char))) + (js2-add-to-string c) + (cl-case c + (?< + (cl-incf decl-tags)) + (?> + (cl-decf decl-tags) + (if (zerop decl-tags) + (throw 'return t))))) + (js2-xml-discard-string token) + nil))) + +(defun js2-read-PI (token) + "Scan an XML processing instruction." + (let (c) + (catch 'return + (while (/= js2-EOF_CHAR (setq c (js2-get-char))) + (js2-add-to-string c) + (when (and (eq c ??) (eq (js2-peek-char) ?>)) + (setq c (js2-get-char)) ;; Skip > + (js2-add-to-string c) + (throw 'return t))) + (js2-xml-discard-string token) + nil))) + +;;; Highlighting + +(defun js2-set-face (beg end face &optional record) + "Fontify a region. If RECORD is non-nil, record for later." + (when (cl-plusp js2-highlight-level) + (setq beg (min (point-max) beg) + beg (max (point-min) beg) + end (min (point-max) end) + end (max (point-min) end)) + (if record + (push (list beg end face) js2-mode-fontifications) + (put-text-property beg end 'font-lock-face face)))) + +(defsubst js2-clear-face (beg end) + (remove-text-properties beg end '(font-lock-face nil + help-echo nil + point-entered nil + cursor-sensor-functions nil + c-in-sws nil))) + +(defconst js2-ecma-global-props + (concat "^" + (regexp-opt + '("Infinity" "NaN" "undefined" "arguments") t) + "$") + "Value properties of the Ecma-262 Global Object. +Shown at or above `js2-highlight-level' 2.") + +;; might want to add the name "arguments" to this list? +(defconst js2-ecma-object-props + (concat "^" + (regexp-opt + '("prototype" "__proto__" "__parent__") t) + "$") + "Value properties of the Ecma-262 Object constructor. +Shown at or above `js2-highlight-level' 2.") + +(defconst js2-ecma-global-funcs + (concat + "^" + (regexp-opt + '("decodeURI" "decodeURIComponent" "encodeURI" "encodeURIComponent" + "eval" "isFinite" "isNaN" "parseFloat" "parseInt") t) + "$") + "Function properties of the Ecma-262 Global object. +Shown at or above `js2-highlight-level' 2.") + +(defconst js2-ecma-number-props + (concat "^" + (regexp-opt '("MAX_VALUE" "MIN_VALUE" "NaN" + "NEGATIVE_INFINITY" + "POSITIVE_INFINITY") t) + "$") + "Properties of the Ecma-262 Number constructor. +Shown at or above `js2-highlight-level' 2.") + +(defconst js2-ecma-date-props "^\\(parse\\|UTC\\)$" + "Properties of the Ecma-262 Date constructor. +Shown at or above `js2-highlight-level' 2.") + +(defconst js2-ecma-math-props + (concat "^" + (regexp-opt + '("E" "LN10" "LN2" "LOG2E" "LOG10E" "PI" "SQRT1_2" "SQRT2") + t) + "$") + "Properties of the Ecma-262 Math object. +Shown at or above `js2-highlight-level' 2.") + +(defconst js2-ecma-math-funcs + (concat "^" + (regexp-opt + '("abs" "acos" "asin" "atan" "atan2" "ceil" "cos" "exp" "floor" + "log" "max" "min" "pow" "random" "round" "sin" "sqrt" "tan") t) + "$") + "Function properties of the Ecma-262 Math object. +Shown at or above `js2-highlight-level' 2.") + +(defconst js2-ecma-function-props + (concat + "^" + (regexp-opt + '(;; properties of the Object prototype object + "hasOwnProperty" "isPrototypeOf" "propertyIsEnumerable" + "toLocaleString" "toString" "valueOf" + ;; properties of the Function prototype object + "apply" "call" + ;; properties of the Array prototype object + "concat" "join" "pop" "push" "reverse" "shift" "slice" "sort" + "splice" "unshift" + ;; properties of the String prototype object + "charAt" "charCodeAt" "fromCharCode" "indexOf" "lastIndexOf" + "localeCompare" "match" "replace" "search" "split" "substring" + "toLocaleLowerCase" "toLocaleUpperCase" "toLowerCase" + "toUpperCase" + ;; properties of the Number prototype object + "toExponential" "toFixed" "toPrecision" + ;; properties of the Date prototype object + "getDate" "getDay" "getFullYear" "getHours" "getMilliseconds" + "getMinutes" "getMonth" "getSeconds" "getTime" + "getTimezoneOffset" "getUTCDate" "getUTCDay" "getUTCFullYear" + "getUTCHours" "getUTCMilliseconds" "getUTCMinutes" "getUTCMonth" + "getUTCSeconds" "setDate" "setFullYear" "setHours" + "setMilliseconds" "setMinutes" "setMonth" "setSeconds" "setTime" + "setUTCDate" "setUTCFullYear" "setUTCHours" "setUTCMilliseconds" + "setUTCMinutes" "setUTCMonth" "setUTCSeconds" "toDateString" + "toLocaleDateString" "toLocaleString" "toLocaleTimeString" + "toTimeString" "toUTCString" + ;; properties of the RegExp prototype object + "exec" "test" + ;; properties of the JSON prototype object + "parse" "stringify" + ;; SpiderMonkey/Rhino extensions, versions 1.5+ + "toSource" "__defineGetter__" "__defineSetter__" + "__lookupGetter__" "__lookupSetter__" "__noSuchMethod__" + "every" "filter" "forEach" "lastIndexOf" "map" "some") + t) + "$") + "Built-in functions defined by Ecma-262 and SpiderMonkey extensions. +Shown at or above `js2-highlight-level' 3.") + +(defun js2-parse-highlight-prop-get (parent target prop call-p) + (let ((target-name (and target + (js2-name-node-p target) + (js2-name-node-name target))) + (prop-name (if prop (js2-name-node-name prop))) + (level2 (>= js2-highlight-level 2)) + (level3 (>= js2-highlight-level 3))) + (when level2 + (let ((face + (if call-p + (cond + ((and target prop) + (cond + ((and level3 (string-match js2-ecma-function-props prop-name)) + 'font-lock-builtin-face) + ((and target-name prop) + (cond + ((string= target-name "Date") + (if (string-match js2-ecma-date-props prop-name) + 'font-lock-builtin-face)) + ((string= target-name "Math") + (if (string-match js2-ecma-math-funcs prop-name) + 'font-lock-builtin-face)))))) + (prop + (if (string-match js2-ecma-global-funcs prop-name) + 'font-lock-builtin-face))) + (cond + ((and target prop) + (cond + ((string= target-name "Number") + (if (string-match js2-ecma-number-props prop-name) + 'font-lock-constant-face)) + ((string= target-name "Math") + (if (string-match js2-ecma-math-props prop-name) + 'font-lock-constant-face)))) + (prop + (if (string-match js2-ecma-object-props prop-name) + 'font-lock-constant-face)))))) + (when (and (not face) target (not call-p) prop-name) + (setq face 'js2-object-property-access)) + (when face + (let ((pos (+ (js2-node-pos parent) ; absolute + (js2-node-pos prop)))) ; relative + (js2-set-face pos + (+ pos (js2-node-len prop)) + face 'record))))))) + +(defun js2-parse-highlight-member-expr-node (node) + "Perform syntax highlighting of EcmaScript built-in properties. +The variable `js2-highlight-level' governs this highlighting." + (let (face target prop name pos end parent call-p callee) + (cond + ;; case 1: simple name, e.g. foo + ((js2-name-node-p node) + (setq name (js2-name-node-name node)) + ;; possible for name to be nil in rare cases - saw it when + ;; running js2-mode on an elisp buffer. Might as well try to + ;; make it so js2-mode never barfs. + (when name + (setq face (if (string-match js2-ecma-global-props name) + 'font-lock-constant-face)) + (when face + (setq pos (js2-node-pos node) + end (+ pos (js2-node-len node))) + (js2-set-face pos end face 'record)))) + ;; case 2: property access or function call + ((or (js2-prop-get-node-p node) + ;; highlight function call if expr is a prop-get node + ;; or a plain name (i.e. unqualified function call) + (and (setq call-p (js2-call-node-p node)) + (setq callee (js2-call-node-target node)) ; separate setq! + (or (js2-prop-get-node-p callee) + (js2-name-node-p callee)))) + (setq parent node + node (if call-p callee node)) + (if (and call-p (js2-name-node-p callee)) + (setq prop callee) + (setq target (js2-prop-get-node-left node) + prop (js2-prop-get-node-right node))) + (cond + ((js2-name-node-p prop) + ;; case 2(a&c): simple or complex target, simple name, e.g. x[y].bar + (js2-parse-highlight-prop-get parent target prop call-p)) + ((js2-name-node-p target) + ;; case 2b: simple target, complex name, e.g. foo.x[y] + (js2-parse-highlight-prop-get parent target nil call-p))))))) + +(defun js2-parse-highlight-member-expr-fn-name (expr) + "Highlight the `baz' in function foo.bar.baz(args) {...}. +This is experimental Rhino syntax. EXPR is the foo.bar.baz member expr. +We currently only handle the case where the last component is a prop-get +of a simple name. Called before EXPR has a parent node." + (let (pos + (name (and (js2-prop-get-node-p expr) + (js2-prop-get-node-right expr)))) + (when (js2-name-node-p name) + (js2-set-face (setq pos (+ (js2-node-pos expr) ; parent is absolute + (js2-node-pos name))) + (+ pos (js2-node-len name)) + 'font-lock-function-name-face + 'record)))) + +;; source: http://jsdoc.sourceforge.net/ +;; Note - this syntax is for Google's enhanced jsdoc parser that +;; allows type specifications, and needs work before entering the wild. + +(defconst js2-jsdoc-param-tag-regexp + (concat "^\\s-*\\*+\\s-*\\(@" + (regexp-opt '("param" "arg" "argument" "prop" "property" "typedef")) + "\\)" + "\\s-*\\({[^}]+}\\)?" ; optional type + "\\s-*\\[?\\([[:alnum:]_$\.]+\\)?\\]?" ; name + "\\_>") + "Matches jsdoc tags with optional type and optional param name.") + +(defconst js2-jsdoc-typed-tag-regexp + (concat "^\\s-*\\*+\\s-*\\(@\\(?:" + (regexp-opt + '("enum" + "extends" + "field" + "id" + "implements" + "lends" + "mods" + "requires" + "return" + "returns" + "yield" + "yields" + "type" + "throw" + "throws")) + "\\)\\)\\s-*\\({[^}]+}\\)?") + "Matches jsdoc tags with optional type.") + +(defconst js2-jsdoc-arg-tag-regexp + (concat "^\\s-*\\*+\\s-*\\(@\\(?:" + (regexp-opt + '("alias" + "augments" + "borrows" + "callback" + "bug" + "base" + "config" + "default" + "define" + "exception" + "func" + "function" + "member" + "memberOf" + "method" + "module" + "name" + "namespace" + "since" + "suppress" + "this" + "throws" + "version")) + "\\)\\)\\s-+\\([^ \t\n]+\\)") + "Matches jsdoc tags with a single argument.") + +(defconst js2-jsdoc-empty-tag-regexp + (concat "^\\s-*\\*+\\s-*\\(@\\(?:" + (regexp-opt + '("abstract" + "addon" + "author" + "class" + "const" + "constant" + "constructor" + "constructs" + "deprecated" + "desc" + "description" + "event" + "example" + "exec" + "export" + "fileoverview" + "final" + "func" + "function" + "hidden" + "ignore" + "implicitCast" + "inheritDoc" + "inner" + "interface" + "license" + "method" + "noalias" + "noshadow" + "notypecheck" + "override" + "owner" + "preserve" + "preserveTry" + "private" + "protected" + "public" + "static" + "supported" + "virtual" + )) + "\\)\\)\\s-*") + "Matches empty jsdoc tags.") + +(defconst js2-jsdoc-link-tag-regexp + "{\\(@\\(?:link\\|code\\)\\)\\s-+\\([^#}\n]+\\)\\(#.+\\)?}" + "Matches a jsdoc link or code tag.") + +(defconst js2-jsdoc-see-tag-regexp + "^\\s-*\\*+\\s-*\\(@see\\)\\s-+\\([^#}\n]+\\)\\(#.+\\)?" + "Matches a jsdoc @see tag.") + +(defconst js2-jsdoc-html-tag-regexp + "\\(</?\\)\\([[:alpha:]]+\\)\\s-*\\(/?>\\)" + "Matches a simple (no attributes) html start- or end-tag.") + +(defun js2-jsdoc-highlight-helper () + (js2-set-face (match-beginning 1) + (match-end 1) + 'js2-jsdoc-tag) + (if (match-beginning 2) + (if (save-excursion + (goto-char (match-beginning 2)) + (= (char-after) ?{)) + (js2-set-face (1+ (match-beginning 2)) + (1- (match-end 2)) + 'js2-jsdoc-type) + (js2-set-face (match-beginning 2) + (match-end 2) + 'js2-jsdoc-value))) + (if (match-beginning 3) + (js2-set-face (match-beginning 3) + (match-end 3) + 'js2-jsdoc-value))) + +(defun js2-highlight-jsdoc (ast) + "Highlight doc comment tags." + (let ((comments (js2-ast-root-comments ast)) + beg end) + (save-excursion + (dolist (node comments) + (when (eq (js2-comment-node-format node) 'jsdoc) + ;; Slice off the leading /* and trailing */ in case there + ;; are tags on the first line + (setq beg (+ 2 (js2-node-abs-pos node)) + end (+ beg -4 (js2-node-len node))) + (save-restriction + (narrow-to-region beg end) + (dolist (re (list js2-jsdoc-param-tag-regexp + js2-jsdoc-typed-tag-regexp + js2-jsdoc-arg-tag-regexp + js2-jsdoc-link-tag-regexp + js2-jsdoc-see-tag-regexp + js2-jsdoc-empty-tag-regexp)) + (goto-char beg) + (while (re-search-forward re nil t) + (js2-jsdoc-highlight-helper))) + ;; simple highlighting for html tags + (goto-char beg) + (while (re-search-forward js2-jsdoc-html-tag-regexp nil t) + (js2-set-face (match-beginning 1) + (match-end 1) + 'js2-jsdoc-html-tag-delimiter) + (js2-set-face (match-beginning 2) + (match-end 2) + 'js2-jsdoc-html-tag-name) + (js2-set-face (match-beginning 3) + (match-end 3) + 'js2-jsdoc-html-tag-delimiter)))))))) + +(defun js2-highlight-assign-targets (_node left right) + "Highlight function properties and external variables." + (let (leftpos name) + ;; highlight vars and props assigned function values + (when (or (js2-function-node-p right) + (js2-class-node-p right)) + (cond + ;; var foo = function() {...} + ((js2-name-node-p left) + (setq name left)) + ;; foo.bar.baz = function() {...} + ((and (js2-prop-get-node-p left) + (js2-name-node-p (js2-prop-get-node-right left))) + (setq name (js2-prop-get-node-right left)))) + (when name + (js2-set-face (setq leftpos (js2-node-abs-pos name)) + (+ leftpos (js2-node-len name)) + 'font-lock-function-name-face + 'record))))) + +(defun js2-record-name-node (node) + "Saves NODE to `js2-recorded-identifiers' to check for undeclared variables +later. NODE must be a name node." + (let ((leftpos (js2-node-abs-pos node))) + (push (list node js2-current-scope + leftpos + (+ leftpos (js2-node-len node))) + js2-recorded-identifiers))) + +(defun js2-highlight-undeclared-vars () + "After entire parse is finished, look for undeclared variable references. +We have to wait until entire buffer is parsed, since JavaScript permits var +declarations to occur after they're used. + +Some identifiers may be assumed to be externally defined. +These externs are not highlighted, even if there is no declaration +for them in the source code (in the current file). + +The list of externs consists of the following: + + - `js2-ecma262-externs' for basic names from the ECMAScript language standard. + - Depending on the buffer-local variables `js2-include-*-externs' + the corresponding `js2-*-externs' to add names for certain environments + like the browser, Node or Rhino. + - Two customizable lists `js2-global-externs' and `js2-additional-externs', + the latter of which should be set per-buffer. + +See especially `js2-additional-externs' for further details about externs." + (let ((default-externs + (append js2-ecma-262-externs + (if (and js2-include-browser-externs + (>= js2-language-version 200)) js2-harmony-externs) + (if js2-include-rhino-externs js2-rhino-externs) + (if js2-include-node-externs js2-node-externs) + (if (or js2-include-browser-externs js2-include-node-externs) + js2-typed-array-externs) + (if js2-include-browser-externs js2-browser-externs))) + name) + (dolist (entry js2-recorded-identifiers) + (cl-destructuring-bind (name-node scope pos end) entry + (setq name (js2-name-node-name name-node)) + (unless (or (member name js2-global-externs) + (member name default-externs) + (member name js2-additional-externs) + (js2-get-defining-scope scope name pos)) + (js2-report-warning "msg.undeclared.variable" name pos (- end pos) + 'js2-external-variable)))))) + +(defun js2--add-or-update-symbol (symbol inition used vars) + "Add or update SYMBOL entry in VARS, an hash table. +SYMBOL is a js2-name-node, INITION either nil, t, or ?P, +respectively meaning that SYMBOL is a mere declaration, an +assignment or a function parameter; when USED is t, the symbol +node is assumed to be an usage and thus added to the list stored +in the cdr of the entry. +" + (let* ((nm (js2-name-node-name symbol)) + (es (js2-node-get-enclosing-scope symbol)) + (ds (js2-get-defining-scope es nm))) + (when (and ds (not (equal nm "arguments"))) + (let* ((sym (js2-scope-get-symbol ds nm)) + (var (gethash sym vars)) + (err-var-p (js2-catch-node-p ds))) + (unless inition + (setq inition err-var-p)) + (if var + (progn + (when (and inition (not (equal (car var) ?P))) + (setcar var inition)) + (when (and used (not (memq symbol (cdr var)))) + (push symbol (cdr var)))) + ;; do not consider the declaration of catch parameter as an usage + (when (and err-var-p used) + (setq used nil)) + (puthash sym (cons inition (if used (list symbol))) vars)))))) + +(defun js2--collect-target-symbols (node strict) + "Collect the `js-name-node' symbols declared in NODE and return a list of them. +NODE is either `js2-array-node', `js2-object-node', or `js2-name-node'. +When STRICT, signal an error if NODE is not one of the expected types." + (let (targets) + (cond + ((js2-name-node-p node) + (push node targets)) + ((js2-array-node-p node) + (dolist (elt (js2-array-node-elems node)) + (when elt + (setq elt (cond ((js2-infix-node-p elt) ;; default (=) + (js2-infix-node-left elt)) + ((js2-unary-node-p elt) ;; rest (...) + (js2-unary-node-operand elt)) + (t elt))) + (setq targets (append (js2--collect-target-symbols elt strict) + targets))))) + ((js2-object-node-p node) + (dolist (elt (js2-object-node-elems node)) + (let ((subexpr (cond + ((and (js2-infix-node-p elt) + (= js2-ASSIGN (js2-infix-node-type elt))) + ;; Destructuring with default argument. + (js2-infix-node-left elt)) + ((and (js2-infix-node-p elt) + (= js2-COLON (js2-infix-node-type elt))) + ;; In regular destructuring {a: aa, b: bb}, + ;; the var is on the right. In abbreviated + ;; destructuring {a, b}, right == left. + (js2-infix-node-right elt)) + ((and (js2-unary-node-p elt) + (= js2-TRIPLEDOT (js2-unary-node-type elt))) + ;; Destructuring with spread. + (js2-unary-node-operand elt))))) + (when subexpr + (setq targets (append + (js2--collect-target-symbols subexpr strict) + targets)))))) + ((js2-assign-node-p node) + (setq targets (append (js2--collect-target-symbols + (js2-assign-node-left node) strict) + targets))) + (strict + (js2-report-error "msg.no.parm" nil (js2-node-abs-pos node) + (js2-node-len node)) + nil)) + targets)) + +(defun js2--examine-variable (parent node var-init-node) + "Examine the usage of the variable NODE, a js2-name-node. +PARENT is its direct ancestor and VAR-INIT-NODE is the node to be +examined: return a list of three values, respectively if the +variable is declared and/or assigned or whether it is simply a +key of a literal object." + (let ((target (js2-var-init-node-target var-init-node)) + declared assigned object-key) + (setq declared (memq node (js2--collect-target-symbols target nil))) + ;; Is there an initializer for the declared variable? + (when (js2-var-init-node-initializer var-init-node) + (setq assigned declared) + ;; Determine if the name is actually a literal object key that we shall + ;; ignore later + (when (and (not declared) + (js2-object-prop-node-p parent) + (eq node (js2-object-prop-node-left parent))) + (setq object-key t))) + ;; Maybe this is a for loop and the variable is one of its iterators? + (unless assigned + (let* ((gp (js2-node-parent parent)) + (ggp (if gp (js2-node-parent gp)))) + (when (and ggp (js2-for-in-node-p ggp)) + (setq assigned (memq node + (cl-loop + for kid in (js2-var-decl-node-kids + (js2-for-in-node-iterator ggp)) + with syms = '() + do + (setq syms (append syms + (js2--collect-target-symbols + (js2-var-init-node-target kid) + nil))) + finally return syms)))))) + (list declared assigned object-key))) + +(defun js2--classify-variable (parent node vars) + "Classify the single variable NODE, a js2-name-node." + (let ((function-param (and (js2-function-node-p parent) + (memq node (js2-function-node-params parent))))) + (if (js2-prop-get-node-p parent) + ;; If we are within a prop-get, e.g. the "bar" in "foo.bar", + ;; just mark "foo" as used + (let ((left (js2-prop-get-node-left parent))) + (when (js2-name-node-p left) + (js2--add-or-update-symbol left nil t vars))) + ;; If the node is the external name of an export-binding-node, and + ;; it is different from the local name, ignore it + (when (or (not (js2-export-binding-node-p parent)) + (not (and (eq (js2-export-binding-node-extern-name parent) node) + (not (eq (js2-export-binding-node-local-name parent) node))))) + (let ((granparent parent) + var-init-node + assign-node + object-key ; is name actually an object prop key? + declared ; is it declared in narrowest scope? + assigned ; does it get assigned or initialized? + (used (null function-param))) + ;; Determine the closest var-init-node and assign-node: this + ;; is needed because the name may be within a "destructured" + ;; declaration/assignment, so we cannot just take its parent + (while (and granparent (not (js2-scope-p granparent))) + (cond + ((js2-var-init-node-p granparent) + (when (null var-init-node) + (setq var-init-node granparent))) + ((js2-assign-node-p granparent) + (when (null assign-node) + (setq assign-node granparent)))) + (setq granparent (js2-node-parent granparent))) + + ;; If we are within a var-init-node, determine if the name is + ;; declared and initialized + (when var-init-node + (let ((result (js2--examine-variable parent node var-init-node))) + (setq declared (car result) + assigned (cadr result) + object-key (car (cddr result))))) + + ;; Ignore literal object keys, which are not really variables + (unless object-key + (when function-param + (setq assigned ?P)) + + (when (null assigned) + (cond + ((js2-for-in-node-p parent) + (setq assigned (eq node (js2-for-in-node-iterator parent)) + used (not assigned))) + ((js2-function-node-p parent) + (setq assigned t + used (js2-wrapper-function-p parent))) + ((js2-export-binding-node-p parent) + (if (js2-import-clause-node-p (js2-node-parent parent)) + (setq declared t + assigned t) + (setq used t))) + ((js2-namespace-import-node-p parent) + (setq assigned t + used nil)) + (assign-node + (setq assigned (memq node + (js2--collect-target-symbols + (js2-assign-node-left assign-node) + nil)) + used (not assigned))))) + + (when declared + (setq used nil)) + + (js2--add-or-update-symbol node assigned used vars))))))) + +(defun js2--classify-variables () + "Collect and classify variables declared or used within js2-mode-ast. +Traverse the whole ast tree returning a summary of the variables +usage as an hash-table, keyed by their corresponding symbol table +entry. +Each variable is described by a tuple where the car is a flag +indicating whether the variable has been initialized and the cdr +is a possibly empty list of name nodes where it is used. External +symbols, i.e. those not present in the whole scopes hierarchy, +are ignored." + (let ((vars (make-hash-table :test #'eq :size 100))) + (js2-visit-ast + js2-mode-ast + (lambda (node end-p) + (when (and (null end-p) (js2-name-node-p node)) + (let ((parent (js2-node-parent node))) + (when parent + (js2--classify-variable parent node vars)))) + t)) + vars)) + +(defun js2--get-name-node (node) + (cond + ((js2-name-node-p node) node) + ((js2-function-node-p node) + (js2-function-node-name node)) + ((js2-class-node-p node) + (js2-class-node-name node)) + ((js2-comp-loop-node-p node) + (js2-comp-loop-node-iterator node)) + (t node))) + +(defun js2--highlight-unused-variable (symbol info) + (let ((name (js2-symbol-name symbol)) + (inited (car info)) + (refs (cdr info)) + pos len) + (unless (and inited refs) + (if refs + (dolist (ref refs) + (setq pos (js2-node-abs-pos ref)) + (setq len (js2-name-node-len ref)) + (js2-report-warning "msg.uninitialized.variable" name pos len + 'js2-warning)) + (when (or js2-warn-about-unused-function-arguments + (not (eq inited ?P))) + (let* ((symn (js2-symbol-ast-node symbol)) + (namen (js2--get-name-node symn))) + (unless (js2-node-top-level-decl-p namen) + (setq pos (js2-node-abs-pos namen)) + (setq len (js2-name-node-len namen)) + (js2-report-warning "msg.unused.variable" name pos len + 'js2-warning)))))))) + +(defun js2-highlight-unused-variables () + "Highlight unused variables." + (let ((vars (js2--classify-variables))) + (maphash #'js2--highlight-unused-variable vars))) + +;;;###autoload +(define-minor-mode js2-highlight-unused-variables-mode + "Toggle highlight of unused variables." + :lighter "" + (if js2-highlight-unused-variables-mode + (add-hook 'js2-post-parse-callbacks + #'js2-highlight-unused-variables nil t) + (remove-hook 'js2-post-parse-callbacks + #'js2-highlight-unused-variables t))) + +(defun js2-add-additional-externs (externs) + (setq js2-additional-externs + (nconc externs + js2-additional-externs))) + +(defun js2-get-jslint-comment-identifiers (comment) + (js2-reparse) + (cl-loop for node in (js2-ast-root-comments js2-mode-ast) + when (and (eq 'block (js2-comment-node-format node)) + (save-excursion + (goto-char (js2-node-abs-pos node)) + (looking-at (concat "/\\* *" comment "\\(?: \\|$\\)")))) + append (js2-get-jslint-comment-identifiers-in + (match-end 0) + (js2-node-abs-end node)))) + +(defun js2-get-jslint-comment-identifiers-in (beg end) + (let (res) + (save-excursion + (goto-char beg) + (while (re-search-forward js2-mode-identifier-re end t) + (let ((match (match-string 0))) + (unless (member match '("true" "false")) + (push match res))))) + (nreverse res))) + +(defun js2-apply-jslint-globals () + (js2-add-additional-externs (js2-get-jslint-globals))) + +(defun js2-get-jslint-globals () + (js2-get-jslint-comment-identifiers "global")) + +(defun js2-apply-jslint-declaration-externs () + (js2-add-additional-externs (js2-get-jslint-declaration-externs))) + +(defvar js2-jslint-declaration-externs + `(("browser" . ,(mapcar 'symbol-name + '(Audio clearInterval clearTimeout document + event history Image location name + navigator Option screen setInterval + setTimeout XMLHttpRequest))) + ("node" . ,(mapcar 'symbol-name + '(Buffer clearImmediate clearInterval + clearTimeout console exports global module + process querystring require setImmediate + setInterval setTimeout __dirname + __filename))) + ("es6" . ,(mapcar 'symbol-name + '(ArrayBuffer DataView Float32Array + Float64Array Int8Array Int16Array Int32Array + Intl Map Promise Proxy Reflect Set Symbol + System Uint8Array Uint8ClampedArray + Uint16Array Uint32Array WeakMap WeakSet))) + ("couch" . ,(mapcar 'symbol-name + '(emit getRow isArray log provides + registerType require send start sum + toJSON))) + ("devel" . ,(mapcar 'symbol-name + '(alert confirm console Debug opera prompt + WSH))))) + +(defun js2-get-jslint-declaration-externs () + (apply 'append + (mapcar (lambda (identifier) + (cdr (assoc identifier + js2-jslint-declaration-externs))) + (js2-get-jslint-comment-identifiers "jslint")))) + +;;; IMenu support + +;; We currently only support imenu, but eventually should support speedbar and +;; possibly other browsing mechanisms. + +;; The basic strategy is to identify function assignment targets of the form +;; `foo.bar.baz', convert them to (list fn foo bar baz <position>), and push the +;; list into `js2-imenu-recorder'. The lists are merged into a trie-like tree +;; for imenu after parsing is finished. + +;; A `foo.bar.baz' assignment target may be expressed in many ways in +;; JavaScript, and the general problem is undecidable. However, several forms +;; are readily recognizable at parse-time; the forms we attempt to recognize +;; include: + +;; function foo() -- function declaration +;; foo = function() -- function expression assigned to variable +;; foo.bar.baz = function() -- function expr assigned to nested property-get +;; foo = {bar: function()} -- fun prop in object literal assigned to var +;; foo = {bar: {baz: function()}} -- inside nested object literal +;; foo.bar = {baz: function()}} -- obj lit assigned to nested prop get +;; a.b = {c: {d: function()}} -- nested obj lit assigned to nested prop get +;; foo = {get bar() {...}} -- getter/setter in obj literal +;; function foo() {function bar() {...}} -- nested function +;; foo['a'] = function() -- fun expr assigned to deterministic element-get + +;; This list boils down to a few forms that can be combined recursively. +;; Top-level named function declarations include both the left-hand (name) +;; and the right-hand (function value) expressions needed to produce an imenu +;; entry. The other "right-hand" forms we need to look for are: +;; - functions declared as props/getters/setters in object literals +;; - nested named function declarations +;; The "left-hand" expressions that functions can be assigned to include: +;; - local/global variables +;; - nested property-get expressions like a.b.c.d +;; - element gets like foo[10] or foo['bar'] where the index +;; expression can be trivially converted to a property name. They +;; effectively then become property gets. + +;; All the different definition types are canonicalized into the form +;; foo.bar.baz = position-of-function-keyword + +;; We need to build a trie-like structure for imenu. As an example, +;; consider the following JavaScript code: + +;; a = function() {...} // function at position 5 +;; b = function() {...} // function at position 25 +;; foo = function() {...} // function at position 100 +;; foo.bar = function() {...} // function at position 200 +;; foo.bar.baz = function() {...} // function at position 300 +;; foo.bar.zab = function() {...} // function at position 400 + +;; During parsing we accumulate an entry for each definition in +;; the variable `js2-imenu-recorder', like so: + +;; '((fn a 5) +;; (fn b 25) +;; (fn foo 100) +;; (fn foo bar 200) +;; (fn foo bar baz 300) +;; (fn foo bar zab 400)) + +;; Where 'fn' is the respective function node. +;; After parsing these entries are merged into this alist-trie: + +;; '((a . 1) +;; (b . 2) +;; (foo (<definition> . 3) +;; (bar (<definition> . 6) +;; (baz . 100) +;; (zab . 200)))) + +;; Note the wacky need for a <definition> name. The token can be anything +;; that isn't a valid JavaScript identifier, because you might make foo +;; a function and then start setting properties on it that are also functions. + +(defun js2-prop-node-name (node) + "Return the name of a node that may be a property-get/property-name. +If NODE is not a valid name-node, string-node or integral number-node, +returns nil. Otherwise returns the string name/value of the node." + (cond + ((js2-name-node-p node) + (js2-name-node-name node)) + ((js2-string-node-p node) + (js2-string-node-value node)) + ((and (js2-number-node-p node) + (string-match "^[0-9]+$" (js2-number-node-value node))) + (js2-number-node-value node)) + ((eq (js2-node-type node) js2-THIS) + "this") + ((eq (js2-node-type node) js2-SUPER) + "super"))) + +(defun js2-node-qname-component (node) + "Return the name of this node, if it contributes to a qname. +Returns nil if the node doesn't contribute." + (copy-sequence + (or (js2-prop-node-name node) + (cond + ((and (js2-function-node-p node) + (js2-function-node-name node)) + (js2-name-node-name (js2-function-node-name node))) + ((js2-computed-prop-name-node-p node) + "[computed]"))))) + +(defun js2-record-imenu-entry (fn-node qname pos) + "Add an entry to `js2-imenu-recorder'. +FN-NODE should be the current item's function node. + +Associate FN-NODE with its QNAME for later lookup. +This is used in postprocessing the chain list. For each chain, we find +the parent function, look up its qname, then prepend a copy of it to the chain." + (push (cons fn-node (append qname (list pos))) js2-imenu-recorder) + (unless js2-imenu-function-map + (setq js2-imenu-function-map (make-hash-table :test 'eq))) + (puthash fn-node qname js2-imenu-function-map)) + +(defun js2-record-imenu-functions (node &optional var) + "Record function definitions for imenu. +NODE is a function node or an object literal. +VAR, if non-nil, is the expression that NODE is being assigned to. +When passed arguments of wrong type, does nothing." + (when js2-parse-ide-mode + (let ((fun-p (js2-function-node-p node)) + qname fname-node) + (cond + ;; non-anonymous function declaration? + ((and fun-p + (not var) + (setq fname-node (js2-function-node-name node))) + (js2-record-imenu-entry node (list fname-node) (js2-node-pos node))) + ;; for remaining forms, compute left-side tree branch first + ((and var (setq qname (js2-compute-nested-prop-get var))) + (cond + ;; foo.bar.baz = function + (fun-p + (js2-record-imenu-entry node qname (js2-node-pos node))) + ;; foo.bar.baz = object-literal + ;; look for nested functions: {a: {b: function() {...} }} + ((js2-object-node-p node) + ;; Node position here is still absolute, since the parser + ;; passes the assignment target and value expressions + ;; to us before they are added as children of the assignment node. + (js2-record-object-literal node qname (js2-node-pos node))))))))) + +(defun js2-compute-nested-prop-get (node) + "If NODE is of form foo.bar, foo[\\='bar\\='], or any nested combination, return +component nodes as a list. Otherwise return nil. Element-gets are treated +as property-gets if the index expression is a string, or a positive integer." + (let (left right head) + (cond + ((or (js2-name-node-p node) + (js2-this-or-super-node-p node)) + (list node)) + ;; foo.bar.baz is parenthesized as (foo.bar).baz => right operand is a leaf + ((js2-prop-get-node-p node) ; foo.bar + (setq left (js2-prop-get-node-left node) + right (js2-prop-get-node-right node)) + (if (setq head (js2-compute-nested-prop-get left)) + (nconc head (list right)))) + ((js2-elem-get-node-p node) ; foo['bar'] or foo[101] + (setq left (js2-elem-get-node-target node) + right (js2-elem-get-node-element node)) + (if (or (js2-string-node-p right) ; ['bar'] + (and (js2-number-node-p right) ; [10] + (string-match "^[0-9]+$" + (js2-number-node-value right)))) + (if (setq head (js2-compute-nested-prop-get left)) + (nconc head (list right)))))))) + +(defun js2-record-object-literal (node qname pos) + "Recursively process an object literal looking for functions. +NODE is an object literal that is the right-hand child of an assignment +expression. QNAME is a list of nodes representing the assignment target, +e.g. for foo.bar.baz = {...}, QNAME is (foo-node bar-node baz-node). +POS is the absolute position of the node. +We do a depth-first traversal of NODE. For any functions we find, +we append the property name to QNAME, then call `js2-record-imenu-entry'." + (let (right) + (dolist (e (js2-object-node-elems node)) ; e is a `js2-object-prop-node' + (when (js2-infix-node-p e) + (let ((left (js2-infix-node-left e)) + ;; Element positions are relative to the parent position. + (pos (+ pos (js2-node-pos e)))) + (cond + ;; foo: function() {...} + ((js2-function-node-p (setq right (js2-infix-node-right e))) + (when (js2-prop-node-name left) + ;; As a policy decision, we record the position of the property, + ;; not the position of the `function' keyword, since the property + ;; is effectively the name of the function. + (js2-record-imenu-entry right (append qname (list left)) pos))) + ;; foo: {object-literal} -- add foo to qname, offset position, and recurse + ((js2-object-node-p right) + (js2-record-object-literal right + (append qname (list (js2-infix-node-left e))) + (+ pos (js2-node-pos right)))))))))) + +(defun js2-node-top-level-decl-p (node) + "Return t if NODE's name is defined in the top-level scope. +Also returns t if NODE's name is not defined in any scope, since it implies +that it's an external variable, which must also be in the top-level scope." + (let* ((name (js2-prop-node-name node)) + (this-scope (js2-node-get-enclosing-scope node)) + defining-scope) + (cond + ((js2-this-or-super-node-p node) + nil) + ((null this-scope) + t) + ((setq defining-scope (js2-get-defining-scope this-scope name)) + (js2-ast-root-p defining-scope)) + (t t)))) + +(defun js2-wrapper-function-p (node) + "Return t if NODE is a function expression that's immediately invoked. +NODE must be `js2-function-node'." + (let ((parent (js2-node-parent node))) + (or + ;; function(){...}(); + (and (js2-call-node-p parent) + (eq node (js2-call-node-target parent))) + (and (js2-paren-node-p parent) + ;; (function(){...})(); + (or (js2-call-node-p (setq parent (js2-node-parent parent))) + ;; (function(){...}).call(this); + (and (js2-prop-get-node-p parent) + (member (js2-name-node-name (js2-prop-get-node-right parent)) + '("call" "apply")) + (js2-call-node-p (js2-node-parent parent)))))))) + +(defun js2-browse-postprocess-chains () + "Modify function-declaration name chains after parsing finishes. +Some of the information is only available after the parse tree is complete. +For instance, processing a nested scope requires a parent function node." + (let (result fn parent-qname p elem) + (dolist (entry js2-imenu-recorder) + ;; function node goes first + (cl-destructuring-bind (current-fn &rest (&whole chain head &rest)) entry + ;; Examine head's defining scope: + ;; Pre-processed chain, or top-level/external, keep as-is. + (if (or (stringp head) (js2-node-top-level-decl-p head)) + (push chain result) + (when (js2-this-or-super-node-p head) + (setq chain (cdr chain))) ; discard this-node + (when (setq fn (js2-node-parent-script-or-fn current-fn)) + (setq parent-qname (gethash fn js2-imenu-function-map 'not-found)) + (when (eq parent-qname 'not-found) + ;; anonymous function expressions are not recorded + ;; during the parse, so we need to handle this case here + (setq parent-qname + (if (js2-wrapper-function-p fn) + (let ((grandparent (js2-node-parent-script-or-fn fn))) + (if (js2-ast-root-p grandparent) + nil + (gethash grandparent js2-imenu-function-map 'skip))) + 'skip)) + (puthash fn parent-qname js2-imenu-function-map)) + (if (eq parent-qname 'skip) + ;; We don't show it, let's record that fact. + (remhash current-fn js2-imenu-function-map) + ;; Prepend parent fn qname to this chain. + (let ((qname (append parent-qname chain))) + (puthash current-fn (butlast qname) js2-imenu-function-map) + (push qname result))))))) + ;; Collect chains obtained by third-party code. + (let (js2-imenu-recorder) + (run-hooks 'js2-build-imenu-callbacks) + (dolist (entry js2-imenu-recorder) + (push (cdr entry) result))) + ;; Finally replace each node in each chain with its name. + (dolist (chain result) + (setq p chain) + (while p + (if (js2-node-p (setq elem (car p))) + (setcar p (js2-node-qname-component elem))) + (setq p (cdr p)))) + result)) + +;; Merge name chains into a trie-like tree structure of nested lists. +;; To simplify construction of the trie, we first build it out using the rule +;; that the trie consists of lists of pairs. Each pair is a 2-element array: +;; [key, num-or-list]. The second element can be a number; if so, this key +;; is a leaf-node with only one value. (I.e. there is only one declaration +;; associated with the key at this level.) Otherwise the second element is +;; a list of pairs, with the rule applied recursively. This symmetry permits +;; a simple recursive formulation. +;; +;; js2-mode is building the data structure for imenu. The imenu documentation +;; claims that it's the structure above, but in practice it wants the children +;; at the same list level as the key for that level, which is how I've drawn +;; the "Expected final result" above. We'll postprocess the trie to remove the +;; list wrapper around the children at each level. +;; +;; A completed nested imenu-alist entry looks like this: +;; '(("foo" +;; ("<definition>" . 7) +;; ("bar" +;; ("a" . 40) +;; ("b" . 60)))) +;; +;; In particular, the documentation for `imenu--index-alist' says that +;; a nested sub-alist element looks like (INDEX-NAME SUB-ALIST). +;; The sub-alist entries immediately follow INDEX-NAME, the head of the list. + +(defun js2-treeify (lst) + "Convert (a b c d) to (a ((b ((c d)))))." + (if (null (cddr lst)) ; list length <= 2 + lst + (list (car lst) (list (js2-treeify (cdr lst)))))) + +(defun js2-build-alist-trie (chains trie) + "Merge declaration name chains into a trie-like alist structure for imenu. +CHAINS is the qname chain list produced during parsing. TRIE is a +list of elements built up so far." + (let (head tail pos branch kids) + (dolist (chain chains) + (setq head (car chain) + tail (cdr chain) + pos (if (numberp (car tail)) (car tail)) + branch (js2-find-if (lambda (n) + (string= (car n) head)) + trie) + kids (cl-second branch)) + (cond + ;; case 1: this key isn't in the trie yet + ((null branch) + (if trie + (setcdr (last trie) (list (js2-treeify chain))) + (setq trie (list (js2-treeify chain))))) + ;; case 2: key is present with a single number entry: replace w/ list + ;; ("a1" 10) + ("a1" 20) => ("a1" (("<definition>" 10) + ;; ("<definition>" 20))) + ((numberp kids) + (setcar (cdr branch) + (list (list "<definition-1>" kids) + (if pos + (list "<definition-2>" pos) + (js2-treeify tail))))) + ;; case 3: key is there (with kids), and we're a number entry + (pos + (setcdr (last kids) + (list + (list (format "<definition-%d>" + (1+ (cl-loop for kid in kids + count (eq ?< (aref (car kid) 0))))) + pos)))) + ;; case 4: key is there with kids, need to merge in our chain + (t + (js2-build-alist-trie (list tail) kids)))) + trie)) + +(defun js2-flatten-trie (trie) + "Convert TRIE to imenu-format. +Recurses through nodes, and for each one whose second element is a list, +appends the list's flattened elements to the current element. Also +changes the tails into conses. For instance, this pre-flattened trie + + (a ((b 20) + (c ((d 30) + (e 40))))) + +becomes + + (a (b . 20) + (c (d . 30) + (e . 40))) + +Note that the root of the trie has no key, just a list of chains. +This is also true for the value of any key with multiple children, +e.g. key `c' in the example above." + (cond + ((listp (car trie)) + (mapcar #'js2-flatten-trie trie)) + (t + (if (numberp (cl-second trie)) + (cons (car trie) (cl-second trie)) + ;; else pop list and append its kids + (apply #'append (list (car trie)) (js2-flatten-trie (cdr trie))))))) + +(defun js2-build-imenu-index () + "Turn `js2-imenu-recorder' into an imenu data structure." + (when (eq js2-imenu-recorder 'empty) + (setq js2-imenu-recorder nil)) + (let* ((chains (js2-browse-postprocess-chains)) + (result (js2-build-alist-trie chains nil))) + (js2-flatten-trie result))) + +(defun js2-test-print-chains (chains) + "Print a list of qname chains. +Each element of CHAINS is a list of the form (NODE [NODE *] pos); +i.e. one or more nodes, and an integer position as the list tail." + (mapconcat (lambda (chain) + (concat "(" + (mapconcat (lambda (elem) + (if (js2-node-p elem) + (or (js2-node-qname-component elem) + "nil") + (number-to-string elem))) + chain + " ") + ")")) + chains + "\n")) + +;;; Parser + +(defconst js2-version "1.8.5" + "Version of JavaScript supported.") + +(defun js2-record-face (face &optional token) + "Record a style run of FACE for TOKEN or the current token." + (unless token (setq token (js2-current-token))) + (js2-set-face (js2-token-beg token) (js2-token-end token) face 'record)) + +(defsubst js2-node-end (n) + "Computes the absolute end of node N. +Use with caution! Assumes `js2-node-pos' is -absolute-, which +is only true until the node is added to its parent; i.e., while parsing." + (+ (js2-node-pos n) + (js2-node-len n))) + +(defun js2-record-comment (token) + "Record a comment in `js2-scanned-comments'." + (let ((ct (js2-token-comment-type token)) + (beg (js2-token-beg token)) + (end (js2-token-end token))) + (push (make-js2-comment-node :len (- end beg) + :format ct) + js2-scanned-comments) + (when js2-parse-ide-mode + (js2-record-face (if (eq ct 'jsdoc) + 'font-lock-doc-face + 'font-lock-comment-face) + token) + (when (memq ct '(html preprocessor)) + ;; Tell cc-engine the bounds of the comment. + (js2-record-text-property beg (1- end) 'c-in-sws t))))) + +(defun js2-peek-token (&optional modifier) + "Return the next token type without consuming it. +If `js2-ti-lookahead' is positive, return the type of next token +from `js2-ti-tokens'. Otherwise, call `js2-get-token'." + (if (not (zerop js2-ti-lookahead)) + (js2-token-type + (aref js2-ti-tokens (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens))) + (let ((tt (js2-get-token-internal modifier))) + (js2-unget-token) + tt))) + +(defalias 'js2-next-token 'js2-get-token) + +(defun js2-match-token (match &optional dont-unget) + "Get next token and return t if it matches MATCH, a bytecode. +Returns nil and consumes nothing if MATCH is not the next token." + (if (/= (js2-get-token) match) + (ignore (unless dont-unget (js2-unget-token))) + t)) + +(defun js2-match-contextual-kwd (name) + "Consume and return t if next token is `js2-NAME', and its +string is NAME. Returns nil and keeps current token otherwise." + (if (js2-contextual-kwd-p (progn (js2-get-token) + (js2-current-token)) + name) + (progn (js2-record-face 'font-lock-keyword-face) t) + (js2-unget-token) + nil)) + +(defun js2-contextual-kwd-p (token name) + "Return t if TOKEN is `js2-NAME', and its string is NAME." + (and (= (js2-token-type token) js2-NAME) + (string= (js2-token-string token) name))) + +(defun js2-match-async-function () + (when (and (js2-contextual-kwd-p (js2-current-token) "async") + (= (js2-peek-token) js2-FUNCTION)) + (js2-record-face 'font-lock-keyword-face) + (js2-get-token) + t)) + +(defun js2-match-async-arrow-function () + (and (js2-contextual-kwd-p (js2-current-token) "async") + (/= (js2-peek-token) js2-FUNCTION))) + +(defsubst js2-inside-function () + (cl-plusp js2-nesting-of-function)) + +(defsubst js2-inside-async-function () + (and (js2-inside-function) + (js2-function-node-async js2-current-script-or-fn))) + +(defun js2-parse-await-maybe (tt) + "Parse \"await\" as an AwaitExpression, if it is one." + (and (= tt js2-NAME) + (js2-contextual-kwd-p (js2-current-token) "await") + ;; Per the proposal, AwaitExpression consists of "await" + ;; followed by a UnaryExpression. So look ahead for one. + (let ((ts-state (make-js2-ts-state)) + (recorded-identifiers js2-recorded-identifiers) + (parsed-errors js2-parsed-errors) + (current-token (js2-current-token)) + (beg (js2-current-token-beg)) + (end (js2-current-token-end)) + pn) + (js2-get-token) + (setq pn (js2-make-unary beg js2-AWAIT 'js2-parse-unary-expr)) + (if (= (js2-node-type (js2-unary-node-operand pn)) js2-ERROR) + ;; The parse failed, so pretend like nothing happened and restore + ;; the previous parsing state. + (progn + (js2-ts-seek ts-state) + (setq js2-recorded-identifiers recorded-identifiers + js2-parsed-errors parsed-errors) + ;; And ensure the caller knows about the failure. + nil) + ;; The parse was successful, so process and return the "await". + (js2-record-face 'font-lock-keyword-face current-token) + (unless (js2-inside-async-function) + (js2-report-error "msg.bad.await" nil + beg (- end beg))) + pn)))) + +(defun js2-get-prop-name-token () + (js2-get-token (and (>= js2-language-version 170) 'KEYWORD_IS_NAME))) + +(defun js2-match-prop-name () + "Consume token and return t if next token is a valid property name. +If `js2-language-version' is >= 180, a keyword or reserved word +is considered valid name as well." + (if (eq js2-NAME (js2-get-prop-name-token)) + t + (js2-unget-token) + nil)) + +(defun js2-must-match-prop-name (msg-id &optional pos len) + (if (js2-match-prop-name) + t + (js2-report-error msg-id nil pos len) + nil)) + +(defun js2-peek-token-or-eol () + "Return js2-EOL if the next token immediately follows a newline. +Else returns the next token. Used in situations where we don't +consider certain token types valid if they are preceded by a newline. +One example is the postfix ++ or -- operator, which has to be on the +same line as its operand." + (let ((tt (js2-get-token)) + (follows-eol (js2-token-follows-eol-p (js2-current-token)))) + (js2-unget-token) + (if follows-eol + js2-EOL + tt))) + +(defun js2-must-match (token msg-id &optional pos len) + "Match next token to token code TOKEN, or record a syntax error. +MSG-ID is the error message to report if the match fails. +Returns t on match, nil if no match." + (if (js2-match-token token t) + t + (js2-report-error msg-id nil pos len) + (js2-unget-token) + nil)) + +(defun js2-must-match-name (msg-id) + (if (js2-match-token js2-NAME t) + t + (if (eq (js2-current-token-type) js2-RESERVED) + (js2-report-error "msg.reserved.id" (js2-current-token-string)) + (js2-report-error msg-id) + (js2-unget-token)) + nil)) + +(defun js2-set-requires-activation () + (if (js2-function-node-p js2-current-script-or-fn) + (setf (js2-function-node-needs-activation js2-current-script-or-fn) t))) + +(defun js2-check-activation-name (name _token) + (when (js2-inside-function) + ;; skip language-version 1.2 check from Rhino + (if (or (string= "arguments" name) + (and js2-compiler-activation-names ; only used in codegen + (gethash name js2-compiler-activation-names))) + (js2-set-requires-activation)))) + +(defun js2-set-is-generator () + (let ((fn-node js2-current-script-or-fn)) + (when (and (js2-function-node-p fn-node) + (not (js2-function-node-generator-type fn-node))) + (setf (js2-function-node-generator-type js2-current-script-or-fn) 'LEGACY)))) + +(defun js2-must-have-xml () + (unless js2-compiler-xml-available + (js2-report-error "msg.XML.not.available"))) + +(defun js2-push-scope (scope) + "Push SCOPE, a `js2-scope', onto the lexical scope chain." + (cl-assert (js2-scope-p scope)) + (cl-assert (null (js2-scope-parent-scope scope))) + (cl-assert (not (eq js2-current-scope scope))) + (setf (js2-scope-parent-scope scope) js2-current-scope + js2-current-scope scope)) + +(defsubst js2-pop-scope () + (setq js2-current-scope + (js2-scope-parent-scope js2-current-scope))) + +(defun js2-enter-loop (loop-node) + (push loop-node js2-loop-set) + (push loop-node js2-loop-and-switch-set) + (js2-push-scope loop-node) + ;; Tell the current labeled statement (if any) its statement, + ;; and set the jump target of the first label to the loop. + ;; These are used in `js2-parse-continue' to verify that the + ;; continue target is an actual labeled loop. (And for codegen.) + (when js2-labeled-stmt + (setf (js2-labeled-stmt-node-stmt js2-labeled-stmt) loop-node + (js2-label-node-loop (car (js2-labeled-stmt-node-labels + js2-labeled-stmt))) loop-node))) + +(defun js2-exit-loop () + (pop js2-loop-set) + (pop js2-loop-and-switch-set) + (js2-pop-scope)) + +(defsubst js2-enter-switch (switch-node) + (js2-push-scope switch-node) + (push switch-node js2-loop-and-switch-set)) + +(defsubst js2-exit-switch () + (js2-pop-scope) + (pop js2-loop-and-switch-set)) + +(defsubst js2-get-directive (node) + "Return NODE's value if it is a directive, nil otherwise. + +A directive is an otherwise-meaningless expression statement +consisting of a string literal, such as \"use strict\"." + (and (js2-expr-stmt-node-p node) + (js2-string-node-p (setq node (js2-expr-stmt-node-expr node))) + (js2-string-node-value node))) + +(defun js2-parse (&optional buf cb) + "Tell the js2 parser to parse a region of JavaScript. + +BUF is a buffer or buffer name containing the code to parse. +Call `narrow-to-region' first to parse only part of the buffer. + +The returned AST root node is given some additional properties: + `node-count' - total number of nodes in the AST + `buffer' - BUF. The buffer it refers to may change or be killed, + so the value is not necessarily reliable. + +An optional callback CB can be specified to report parsing +progress. If (functionp CB) returns t, it will be called with +the current line number once before parsing begins, then again +each time the lexer reaches a new line number. + +CB can also be a list of the form (symbol cb ...) to specify +multiple callbacks with different criteria. Each symbol is a +criterion keyword, and the following element is the callback to +call + + :line - called whenever the line number changes + :token - called for each new token consumed + +The list of criteria could be extended to include entering or +leaving a statement, an expression, or a function definition." + (if (and cb (not (functionp cb))) + (error "criteria callbacks not yet implemented")) + (let ((inhibit-point-motion-hooks t) + (js2-compiler-xml-available (>= js2-language-version 160)) + ;; This is a recursive-descent parser, so give it a big stack. + (max-lisp-eval-depth (max max-lisp-eval-depth 3000)) + (max-specpdl-size (max max-specpdl-size 3000)) + (case-fold-search nil) + ast) + (with-current-buffer (or buf (current-buffer)) + (setq js2-scanned-comments nil + js2-parsed-errors nil + js2-parsed-warnings nil + js2-imenu-recorder nil + js2-imenu-function-map nil + js2-label-set nil) + (js2-init-scanner) + (setq ast (js2-do-parse)) + (unless js2-ts-hit-eof + (js2-report-error "msg.got.syntax.errors" (length js2-parsed-errors))) + (setf (js2-ast-root-errors ast) js2-parsed-errors + (js2-ast-root-warnings ast) js2-parsed-warnings) + ;; if we didn't find any declarations, put a dummy in this list so we + ;; don't end up re-parsing the buffer in `js2-mode-create-imenu-index' + (unless js2-imenu-recorder + (setq js2-imenu-recorder 'empty)) + (run-hooks 'js2-parse-finished-hook) + ast))) + +;; Corresponds to Rhino's Parser.parse() method. +(defun js2-do-parse () + "Parse current buffer starting from current point. +Scanner should be initialized." + (let ((pos js2-ts-cursor) + (end js2-ts-cursor) ; in case file is empty + root n tt + (in-directive-prologue t) + (js2-in-use-strict-directive js2-in-use-strict-directive) + directive) + ;; initialize buffer-local parsing vars + (setf root (make-js2-ast-root :buffer (buffer-name) :pos pos) + js2-current-script-or-fn root + js2-current-scope root + js2-nesting-of-function 0 + js2-labeled-stmt nil + js2-recorded-identifiers nil ; for js2-highlight + js2-in-use-strict-directive js2-mode-assume-strict) + (while (/= (setq tt (js2-get-token)) js2-EOF) + (if (= tt js2-FUNCTION) + (progn + (setq n (if js2-called-by-compile-function + (js2-parse-function-expr) + (js2-parse-function-stmt)))) + ;; not a function - parse a statement + (js2-unget-token) + (setq n (js2-parse-statement)) + (when in-directive-prologue + (setq directive (js2-get-directive n)) + (cond + ((null directive) + (setq in-directive-prologue nil)) + ((string= directive "use strict") + (setq js2-in-use-strict-directive t))))) + ;; add function or statement to script + (setq end (js2-node-end n)) + (js2-block-node-push root n)) + ;; add comments to root in lexical order + (when js2-scanned-comments + ;; if we find a comment beyond end of normal kids, use its end + (setq end (max end (js2-node-end (cl-first js2-scanned-comments)))) + (dolist (comment js2-scanned-comments) + (push comment (js2-ast-root-comments root)) + (js2-node-add-children root comment))) + (setf (js2-node-len root) (- end pos)) + (setq js2-mode-ast root) ; Make sure this is available for callbacks. + ;; Give extensions a chance to muck with things before highlighting starts. + (let ((js2-additional-externs js2-additional-externs)) + (js2-filter-parsed-warnings) + (save-excursion + (run-hooks 'js2-post-parse-callbacks)) + (js2-highlight-undeclared-vars)) + root)) + +(defun js2-filter-parsed-warnings () + "Remove `js2-parsed-warnings' elements that match `js2-ignored-warnings'." + (when js2-ignored-warnings + (setq js2-parsed-warnings + (cl-remove-if + (lambda (warning) + (let ((msg (caar warning))) + (member msg js2-ignored-warnings))) + js2-parsed-warnings))) + js2-parsed-warnings) + +(defun js2-parse-function-closure-body (fn-node) + "Parse a JavaScript 1.8 function closure body." + (let ((js2-nesting-of-function (1+ js2-nesting-of-function))) + (if js2-ts-hit-eof + (js2-report-error "msg.no.brace.body" nil + (js2-node-pos fn-node) + (- js2-ts-cursor (js2-node-pos fn-node))) + (js2-node-add-children fn-node + (setf (js2-function-node-body fn-node) + (js2-parse-expr t)))))) + +(defun js2-parse-function-body (fn-node) + (js2-must-match js2-LC "msg.no.brace.body" + (js2-node-pos fn-node) + (- js2-ts-cursor (js2-node-pos fn-node))) + (let ((pos (js2-current-token-beg)) ; LC position + (pn (make-js2-block-node)) ; starts at LC position + tt + end + not-in-directive-prologue + node + directive) + (cl-incf js2-nesting-of-function) + (unwind-protect + (while (not (or (= (setq tt (js2-peek-token)) js2-ERROR) + (= tt js2-EOF) + (= tt js2-RC))) + (js2-block-node-push + pn + (if (/= tt js2-FUNCTION) + (if not-in-directive-prologue + (js2-parse-statement) + (setq node (js2-parse-statement) + directive (js2-get-directive node)) + (cond + ((null directive) + (setq not-in-directive-prologue t)) + ((string= directive "use strict") + ;; Back up and reparse the function, because new rules apply + ;; to the function name and parameters. + (when (not js2-in-use-strict-directive) + (setq js2-in-use-strict-directive t) + (throw 'reparse t)))) + node) + (js2-get-token) + (js2-parse-function-stmt)))) + (cl-decf js2-nesting-of-function)) + (setq end (js2-current-token-end)) ; assume no curly and leave at current token + (if (js2-must-match js2-RC "msg.no.brace.after.body" pos) + (setq end (js2-current-token-end))) + (setf (js2-node-pos pn) pos + (js2-node-len pn) (- end pos)) + (setf (js2-function-node-body fn-node) pn) + (js2-node-add-children fn-node pn) + pn)) + +(defun js2-define-destruct-symbols (node decl-type face &optional ignore-not-in-block) + "Declare and fontify destructuring parameters inside NODE. +NODE is either `js2-array-node', `js2-object-node', or `js2-name-node'. + +Return a list of `js2-name-node' nodes representing the symbols +declared; probably to check them for errors." + (let ((name-nodes (js2--collect-target-symbols node t))) + (dolist (node name-nodes) + (let (leftpos) + (js2-define-symbol decl-type (js2-name-node-name node) + node ignore-not-in-block) + (when face + (js2-set-face (setq leftpos (js2-node-abs-pos node)) + (+ leftpos (js2-node-len node)) + face 'record)))) + name-nodes)) + +(defvar js2-illegal-strict-identifiers + '("eval" "arguments") + "Identifiers not allowed as variables in strict mode.") + +(defun js2-check-strict-identifier (name-node) + "Check that NAME-NODE makes a legal strict mode identifier." + (when js2-in-use-strict-directive + (let ((param-name (js2-name-node-name name-node))) + (when (member param-name js2-illegal-strict-identifiers) + (js2-report-error "msg.bad.id.strict" param-name + (js2-node-abs-pos name-node) (js2-node-len name-node)))))) + +(defun js2-check-strict-function-params (preceding-params params) + "Given PRECEDING-PARAMS in a function's parameter list, check +for strict mode errors caused by PARAMS." + (when js2-in-use-strict-directive + (dolist (param params) + (let ((param-name (js2-name-node-name param))) + (js2-check-strict-identifier param) + (when (cl-some (lambda (param) + (string= (js2-name-node-name param) param-name)) + preceding-params) + (js2-report-error "msg.dup.param.strict" param-name + (js2-node-abs-pos param) (js2-node-len param))))))) + +(defun js2-parse-function-params (function-type fn-node pos) + "Parse the parameters of a function of FUNCTION-TYPE +represented by FN-NODE at POS." + (if (js2-match-token js2-RP) + (setf (js2-function-node-rp fn-node) (- (js2-current-token-beg) pos)) + (let ((paren-free-arrow (and (eq function-type 'FUNCTION_ARROW) + (eq (js2-current-token-type) js2-NAME))) + params param + param-name-nodes new-param-name-nodes + rest-param-at) + (when paren-free-arrow + (js2-unget-token)) + (cl-loop for tt = (js2-peek-token) + do + (cond + ;; destructuring param + ((and (not paren-free-arrow) + (or (= tt js2-LB) (= tt js2-LC))) + (js2-get-token) + (setq param (js2-parse-destruct-primary-expr) + new-param-name-nodes (js2-define-destruct-symbols + param js2-LP 'js2-function-param)) + (js2-check-strict-function-params param-name-nodes new-param-name-nodes) + (setq param-name-nodes (append param-name-nodes new-param-name-nodes))) + ;; variable name + (t + (when (and (>= js2-language-version 200) + (not paren-free-arrow) + (js2-match-token js2-TRIPLEDOT) + (not rest-param-at)) + ;; to report errors if there are more parameters + (setq rest-param-at (length params))) + (js2-must-match-name "msg.no.parm") + (js2-record-face 'js2-function-param) + (setq param (js2-create-name-node)) + (js2-define-symbol js2-LP (js2-current-token-string) param) + (js2-check-strict-function-params param-name-nodes (list param)) + (setq param-name-nodes (append param-name-nodes (list param))))) + ;; default parameter value + (when (and (not rest-param-at) + (>= js2-language-version 200) + (js2-match-token js2-ASSIGN)) + (cl-assert (not paren-free-arrow)) + (let* ((pos (js2-node-pos param)) + (tt (js2-current-token-type)) + (op-pos (- (js2-current-token-beg) pos)) + (left param) + (right (js2-parse-assign-expr)) + (len (- (js2-node-end right) pos))) + (setq param (make-js2-assign-node + :type tt :pos pos :len len :op-pos op-pos + :left left :right right)) + (js2-node-add-children param left right))) + (push param params) + (when (and rest-param-at (> (length params) (1+ rest-param-at))) + (js2-report-error "msg.param.after.rest" nil + (js2-node-pos param) (js2-node-len param))) + while + (and (js2-match-token js2-COMMA) + (or (< js2-language-version 200) + (not (= js2-RP (js2-peek-token)))))) + (when (and (not paren-free-arrow) + (js2-must-match js2-RP "msg.no.paren.after.parms")) + (setf (js2-function-node-rp fn-node) (- (js2-current-token-beg) pos))) + (when rest-param-at + (setf (js2-function-node-rest-p fn-node) t)) + (dolist (p params) + (js2-node-add-children fn-node p) + (push p (js2-function-node-params fn-node)))))) + +(defun js2-check-inconsistent-return-warning (fn-node name) + "Possibly show inconsistent-return warning. +Last token scanned is the close-curly for the function body." + (when (and js2-mode-show-strict-warnings + js2-strict-inconsistent-return-warning + (not (js2-has-consistent-return-usage + (js2-function-node-body fn-node)))) + ;; Have it extend from close-curly to bol or beginning of block. + (let ((pos (save-excursion + (goto-char (js2-current-token-end)) + (max (js2-node-abs-pos (js2-function-node-body fn-node)) + (point-at-bol)))) + (end (js2-current-token-end))) + (if (cl-plusp (js2-name-node-length name)) + (js2-add-strict-warning "msg.no.return.value" + (js2-name-node-name name) pos end) + (js2-add-strict-warning "msg.anon.no.return.value" nil pos end))))) + +(defun js2-parse-function-stmt (&optional async-p) + (let ((pos (js2-current-token-beg)) + (star-p (js2-match-token js2-MUL))) + (js2-must-match-name "msg.unnamed.function.stmt") + (let ((name (js2-create-name-node t)) + pn member-expr) + (cond + ((js2-match-token js2-LP) + (js2-parse-function 'FUNCTION_STATEMENT pos star-p async-p name)) + (js2-allow-member-expr-as-function-name + (setq member-expr (js2-parse-member-expr-tail nil name)) + (js2-parse-highlight-member-expr-fn-name member-expr) + (js2-must-match js2-LP "msg.no.paren.parms") + (setf pn (js2-parse-function 'FUNCTION_STATEMENT pos star-p async-p) + (js2-function-node-member-expr pn) member-expr) + pn) + (t + (js2-report-error "msg.no.paren.parms") + (make-js2-error-node)))))) + +(defun js2-parse-async-function-stmt () + (js2-parse-function-stmt t)) + +(defun js2-parse-function-expr (&optional async-p) + (let ((pos (js2-current-token-beg)) + (star-p (js2-match-token js2-MUL)) + name) + (when (js2-match-token js2-NAME) + (setq name (js2-create-name-node t))) + (js2-must-match js2-LP "msg.no.paren.parms") + (js2-parse-function 'FUNCTION_EXPRESSION pos star-p async-p name))) + +(defun js2-parse-function-internal (function-type pos star-p &optional async-p name) + (let (fn-node lp) + (if (= (js2-current-token-type) js2-LP) ; eventually matched LP? + (setq lp (js2-current-token-beg))) + (setf fn-node (make-js2-function-node :pos pos + :name name + :form function-type + :lp (if lp (- lp pos)) + :generator-type (and star-p 'STAR) + :async async-p)) + (when name + (js2-set-face (js2-node-pos name) (js2-node-end name) + 'font-lock-function-name-face 'record) + (when (and (eq function-type 'FUNCTION_STATEMENT) + (cl-plusp (js2-name-node-length name))) + ;; Function statements define a symbol in the enclosing scope + (js2-define-symbol js2-FUNCTION (js2-name-node-name name) fn-node)) + (when js2-in-use-strict-directive + (js2-check-strict-identifier name))) + (if (or (js2-inside-function) (cl-plusp js2-nesting-of-with)) + ;; 1. Nested functions are not affected by the dynamic scope flag + ;; as dynamic scope is already a parent of their scope. + ;; 2. Functions defined under the with statement also immune to + ;; this setup, in which case dynamic scope is ignored in favor + ;; of the with object. + (setf (js2-function-node-ignore-dynamic fn-node) t)) + ;; dynamically bind all the per-function variables + (let ((js2-current-script-or-fn fn-node) + (js2-current-scope fn-node) + (js2-nesting-of-with 0) + (js2-end-flags 0) + js2-label-set + js2-loop-set + js2-loop-and-switch-set) + (js2-parse-function-params function-type fn-node pos) + (when (eq function-type 'FUNCTION_ARROW) + (js2-must-match js2-ARROW "msg.bad.arrow.args")) + (if (and (>= js2-language-version 180) + (/= (js2-peek-token) js2-LC)) + (js2-parse-function-closure-body fn-node) + (js2-parse-function-body fn-node)) + (js2-check-inconsistent-return-warning fn-node name) + + (when name + (js2-node-add-children fn-node name) + ;; Function expressions define a name only in the body of the + ;; function, and only if not hidden by a parameter name + (when (and (eq function-type 'FUNCTION_EXPRESSION) + (null (js2-scope-get-symbol js2-current-scope + (js2-name-node-name name)))) + (js2-define-symbol js2-FUNCTION + (js2-name-node-name name) + fn-node)) + (when (eq function-type 'FUNCTION_STATEMENT) + (js2-record-imenu-functions fn-node)))) + + (setf (js2-node-len fn-node) (- (js2-current-token-end) pos)) + ;; Rhino doesn't do this, but we need it for finding undeclared vars. + ;; We wait until after parsing the function to set its parent scope, + ;; since `js2-define-symbol' needs the defining-scope check to stop + ;; at the function boundary when checking for redeclarations. + (setf (js2-scope-parent-scope fn-node) js2-current-scope) + fn-node)) + +(defun js2-parse-function (function-type pos star-p &optional async-p name) + "Function parser. FUNCTION-TYPE is a symbol, POS is the +beginning of the first token (function keyword, unless it's an +arrow function), NAME is js2-name-node." + (let ((continue t) + ts-state + fn-node + ;; Preserve strict state outside this function. + (js2-in-use-strict-directive js2-in-use-strict-directive)) + ;; Parse multiple times if a new strict mode directive is discovered in the + ;; function body, as new rules will be retroactively applied to the legality + ;; of function names and parameters. + (while continue + (setq ts-state (make-js2-ts-state)) + (setq continue (catch 'reparse + (setq fn-node (js2-parse-function-internal + function-type pos star-p async-p name)) + ;; Don't continue. + nil)) + (when continue + (js2-ts-seek ts-state))) + fn-node)) + +(defun js2-parse-statements (&optional parent) + "Parse a statement list. Last token consumed must be js2-LC. + +PARENT can be a `js2-block-node', in which case the statements are +appended to PARENT. Otherwise a new `js2-block-node' is created +and returned. + +This function does not match the closing js2-RC: the caller +matches the RC so it can provide a suitable error message if not +matched. This means it's up to the caller to set the length of +the node to include the closing RC. The node start pos is set to +the absolute buffer start position, and the caller should fix it +up to be relative to the parent node. All children of this block +node are given relative start positions and correct lengths." + (let ((pn (or parent (make-js2-block-node))) + tt) + (while (and (> (setq tt (js2-peek-token)) js2-EOF) + (/= tt js2-RC)) + (js2-block-node-push pn (js2-parse-statement))) + pn)) + +(defun js2-parse-statement () + (let (pn beg end) + ;; coarse-grained user-interrupt check - needs work + (and js2-parse-interruptable-p + (zerop (% (cl-incf js2-parse-stmt-count) + js2-statements-per-pause)) + (input-pending-p) + (throw 'interrupted t)) + (setq pn (js2-statement-helper)) + ;; no-side-effects warning check + (unless (js2-node-has-side-effects pn) + (setq end (js2-node-end pn)) + (save-excursion + (goto-char end) + (setq beg (max (js2-node-pos pn) (point-at-bol)))) + (js2-add-strict-warning "msg.no.side.effects" nil beg end)) + pn)) + +;; These correspond to the switch cases in Parser.statementHelper +(defconst js2-parsers + (let ((parsers (make-vector js2-num-tokens + #'js2-parse-expr-stmt))) + (aset parsers js2-BREAK #'js2-parse-break) + (aset parsers js2-CLASS #'js2-parse-class-stmt) + (aset parsers js2-CONST #'js2-parse-const-var) + (aset parsers js2-CONTINUE #'js2-parse-continue) + (aset parsers js2-DEBUGGER #'js2-parse-debugger) + (aset parsers js2-DEFAULT #'js2-parse-default-xml-namespace) + (aset parsers js2-DO #'js2-parse-do) + (aset parsers js2-EXPORT #'js2-parse-export) + (aset parsers js2-FOR #'js2-parse-for) + (aset parsers js2-FUNCTION #'js2-parse-function-stmt) + (aset parsers js2-IF #'js2-parse-if) + (aset parsers js2-IMPORT #'js2-parse-import) + (aset parsers js2-LC #'js2-parse-block) + (aset parsers js2-LET #'js2-parse-let-stmt) + (aset parsers js2-NAME #'js2-parse-name-or-label) + (aset parsers js2-RETURN #'js2-parse-ret-yield) + (aset parsers js2-SEMI #'js2-parse-semi) + (aset parsers js2-SWITCH #'js2-parse-switch) + (aset parsers js2-THROW #'js2-parse-throw) + (aset parsers js2-TRY #'js2-parse-try) + (aset parsers js2-VAR #'js2-parse-const-var) + (aset parsers js2-WHILE #'js2-parse-while) + (aset parsers js2-WITH #'js2-parse-with) + (aset parsers js2-YIELD #'js2-parse-ret-yield) + parsers) + "A vector mapping token types to parser functions.") + +(defun js2-parse-warn-missing-semi (beg end) + (and js2-mode-show-strict-warnings + js2-strict-missing-semi-warning + (js2-add-strict-warning + "msg.missing.semi" nil + ;; back up to beginning of statement or line + (max beg (save-excursion + (goto-char end) + (point-at-bol))) + end))) + +(defconst js2-no-semi-insertion + (list js2-IF + js2-SWITCH + js2-WHILE + js2-DO + js2-FOR + js2-TRY + js2-WITH + js2-LC + js2-ERROR + js2-SEMI + js2-CLASS + js2-FUNCTION + js2-EXPORT) + "List of tokens that don't do automatic semicolon insertion.") + +(defconst js2-autoinsert-semi-and-warn + (list js2-ERROR js2-EOF js2-RC)) + +(defun js2-statement-helper () + (let* ((tt (js2-get-token)) + (first-tt tt) + (async-stmt (js2-match-async-function)) + (parser (if (= tt js2-ERROR) + #'js2-parse-semi + (if async-stmt + #'js2-parse-async-function-stmt + (aref js2-parsers tt)))) + pn) + ;; If the statement is set, then it's been told its label by now. + (and js2-labeled-stmt + (js2-labeled-stmt-node-stmt js2-labeled-stmt) + (setq js2-labeled-stmt nil)) + (setq pn (funcall parser)) + ;; Don't do auto semi insertion for certain statement types. + (unless (or (memq first-tt js2-no-semi-insertion) + (js2-labeled-stmt-node-p pn) + async-stmt) + (js2-auto-insert-semicolon pn)) + pn)) + +(defun js2-auto-insert-semicolon (pn) + (let* ((tt (js2-get-token)) + (pos (js2-node-pos pn))) + (cond + ((= tt js2-SEMI) + ;; extend the node bounds to include the semicolon. + (setf (js2-node-len pn) (- (js2-current-token-end) pos))) + ((memq tt js2-autoinsert-semi-and-warn) + (js2-unget-token) ; Not ';', do not consume. + ;; Autoinsert ; + (js2-parse-warn-missing-semi pos (js2-node-end pn))) + (t + (if (not (js2-token-follows-eol-p (js2-current-token))) + ;; Report error if no EOL or autoinsert ';' otherwise + (js2-report-error "msg.no.semi.stmt") + (js2-parse-warn-missing-semi pos (js2-node-end pn))) + (js2-unget-token) ; Not ';', do not consume. + )))) + +(defun js2-parse-condition () + "Parse a parenthesized boolean expression, e.g. in an if- or while-stmt. +The parens are discarded and the expression node is returned. +The `pos' field of the return value is set to an absolute position +that must be fixed up by the caller. +Return value is a list (EXPR LP RP), with absolute paren positions." + (let (pn lp rp) + (if (js2-must-match js2-LP "msg.no.paren.cond") + (setq lp (js2-current-token-beg))) + (setq pn (js2-parse-expr)) + (if (js2-must-match js2-RP "msg.no.paren.after.cond") + (setq rp (js2-current-token-beg))) + ;; Report strict warning on code like "if (a = 7) ..." + (if (and js2-strict-cond-assign-warning + (js2-assign-node-p pn)) + (js2-add-strict-warning "msg.equal.as.assign" nil + (js2-node-pos pn) + (+ (js2-node-pos pn) + (js2-node-len pn)))) + (list pn lp rp))) + +(defun js2-parse-if () + "Parser for if-statement. Last matched token must be js2-IF." + (let ((pos (js2-current-token-beg)) + cond if-true if-false else-pos end pn) + (setq cond (js2-parse-condition) + if-true (js2-parse-statement) + if-false (if (js2-match-token js2-ELSE) + (progn + (setq else-pos (- (js2-current-token-beg) pos)) + (js2-parse-statement))) + end (js2-node-end (or if-false if-true)) + pn (make-js2-if-node :pos pos + :len (- end pos) + :condition (car cond) + :then-part if-true + :else-part if-false + :else-pos else-pos + :lp (js2-relpos (cl-second cond) pos) + :rp (js2-relpos (cl-third cond) pos))) + (js2-node-add-children pn (car cond) if-true if-false) + pn)) + +(defun js2-parse-import () + "Parse import statement. The current token must be js2-IMPORT." + (unless (js2-ast-root-p js2-current-scope) + (js2-report-error "msg.mod.import.decl.at.top.level")) + (let ((beg (js2-current-token-beg))) + (cond ((js2-match-token js2-STRING) + (make-js2-import-node + :pos beg + :len (- (js2-current-token-end) beg) + :module-id (js2-current-token-string))) + (t + (let* ((import-clause (js2-parse-import-clause)) + (from-clause (and import-clause (js2-parse-from-clause))) + (module-id (when from-clause (js2-from-clause-node-module-id from-clause))) + (node (make-js2-import-node + :pos beg + :len (- (js2-current-token-end) beg) + :import import-clause + :from from-clause + :module-id module-id))) + (when import-clause + (js2-node-add-children node import-clause)) + (when from-clause + (js2-node-add-children node from-clause)) + node))))) + +(defun js2-parse-import-clause () + "Parse the bindings in an import statement. +This can take many forms: + +ImportedDefaultBinding -> `foo' +NameSpaceImport -> `* as lib' +NamedImports -> `{foo as bar, bang}' +ImportedDefaultBinding , NameSpaceImport -> `foo, * as lib' +ImportedDefaultBinding , NamedImports -> `foo, {bar, baz as bif}' + +Try to match namespace imports and named imports first because nothing can +come after them. If it is an imported default binding, then it could have named +imports or a namespace import that follows it. +" + (let* ((beg (js2-current-token-beg)) + (clause (make-js2-import-clause-node + :pos beg)) + (children (list))) + (cond + ((js2-match-token js2-MUL) + (let ((ns-import (js2-parse-namespace-import))) + (when ns-import + (let ((name-node (js2-namespace-import-node-name ns-import))) + (js2-define-symbol + js2-LET (js2-name-node-name name-node) name-node t)) + (setf (js2-import-clause-node-namespace-import clause) ns-import) + (push ns-import children)))) + ((js2-match-token js2-LC) + (let ((imports (js2-parse-export-bindings t))) + (setf (js2-import-clause-node-named-imports clause) imports) + (dolist (import imports) + (push import children) + (let ((name-node (js2-export-binding-node-local-name import))) + (when name-node + (js2-define-symbol + js2-LET (js2-name-node-name name-node) name-node t)))))) + ((= (js2-peek-token) js2-NAME) + (let ((binding (js2-maybe-parse-export-binding t))) + (let ((node-name (js2-export-binding-node-local-name binding))) + (js2-define-symbol js2-LET (js2-name-node-name node-name) node-name t)) + (setf (js2-import-clause-node-default-binding clause) binding) + (push binding children)) + (when (js2-match-token js2-COMMA) + (cond + ((js2-match-token js2-MUL) + (let ((ns-import (js2-parse-namespace-import))) + (let ((name-node (js2-namespace-import-node-name ns-import))) + (js2-define-symbol + js2-LET (js2-name-node-name name-node) name-node t)) + (setf (js2-import-clause-node-namespace-import clause) ns-import) + (push ns-import children))) + ((js2-match-token js2-LC) + (let ((imports (js2-parse-export-bindings t))) + (setf (js2-import-clause-node-named-imports clause) imports) + (dolist (import imports) + (push import children) + (let ((name-node (js2-export-binding-node-local-name import))) + (when name-node + (js2-define-symbol + js2-LET (js2-name-node-name name-node) name-node t)))))) + (t (js2-report-error "msg.syntax"))))) + (t (js2-report-error "msg.mod.declaration.after.import"))) + (setf (js2-node-len clause) (- (js2-current-token-end) beg)) + (apply #'js2-node-add-children clause children) + clause)) + +(defun js2-parse-namespace-import () + "Parse a namespace import expression such as `* as bar'. +The current token must be js2-MUL." + (let ((beg (js2-current-token-beg))) + (cond + ((js2-match-contextual-kwd "as") + (when (js2-must-match-prop-name "msg.syntax") + (let ((node (make-js2-namespace-import-node + :pos beg + :len (- (js2-current-token-end) beg) + :name (make-js2-name-node + :pos (js2-current-token-beg) + :len (- (js2-current-token-end) + (js2-current-token-beg)) + :name (js2-current-token-string))))) + (js2-node-add-children node (js2-namespace-import-node-name node)) + node))) + (t + (js2-unget-token) + (js2-report-error "msg.syntax") + nil)))) + + +(defun js2-parse-from-clause () + "Parse the from clause in an import or export statement. +E.g., \"from \\='src/lib\\='\"." + (if (js2-match-contextual-kwd "from") + (let ((beg (js2-current-token-beg))) + (cond + ((js2-match-token js2-STRING) + (make-js2-from-clause-node + :pos beg + :len (- (js2-current-token-end) beg) + :module-id (js2-current-token-string) + :metadata-p nil)) + ((js2-match-token js2-THIS) + (when (js2-must-match-name "msg.mod.spec.after.from") + (if (equal "module" (js2-current-token-string)) + (make-js2-from-clause-node + :pos beg + :len (- (js2-current-token-end) beg) + :module-id "this" + :metadata-p t) + (js2-unget-token) + (js2-unget-token) + (js2-report-error "msg.mod.spec.after.from") + nil))) + (t (js2-report-error "msg.mod.spec.after.from") nil))) + (js2-report-error "msg.mod.from.after.import.spec.set") + nil)) + +(defun js2-parse-export-bindings (&optional import-p) + "Parse a list of export binding expressions such as {}, {foo, bar}, and +{foo as bar, baz as bang}. The current token must be +js2-LC. Return a lisp list of js2-export-binding-node" + (let ((bindings (list))) + (while + (let ((binding (js2-maybe-parse-export-binding import-p))) + (when binding + (push binding bindings)) + (js2-match-token js2-COMMA))) + (when (js2-must-match js2-RC (if import-p + "msg.mod.rc.after.import.spec.list" + "msg.mod.rc.after.export.spec.list")) + (reverse bindings)))) + +(defun js2-maybe-parse-export-binding (&optional import-p) + "Attempt to parse a binding expression found inside an import/export statement. +This can take the form of either as single js2-NAME token as in `foo' or as in a +rebinding expression `bar as foo'. If it matches, it will return an instance of +js2-export-binding-node and consume all the tokens. If it does not match, it +consumes no tokens." + (let ((extern-name (when (js2-match-prop-name) (js2-current-token-string))) + (beg (js2-current-token-beg)) + (extern-name-len (js2-current-token-len)) + (is-reserved-name (or (= (js2-current-token-type) js2-RESERVED) + (aref js2-kwd-tokens (js2-current-token-type))))) + (if extern-name + (if (js2-match-contextual-kwd "as") + (let ((name + (or + (and (js2-match-token js2-DEFAULT) "default") + (and (js2-match-token js2-NAME) (js2-current-token-string))))) + (if name + (let ((node (make-js2-export-binding-node + :pos beg + :len (- (js2-current-token-end) beg) + :local-name (make-js2-name-node + :name name + :pos (js2-current-token-beg) + :len (js2-current-token-len)) + :extern-name (make-js2-name-node + :name extern-name + :pos beg + :len extern-name-len)))) + (js2-node-add-children + node + (js2-export-binding-node-local-name node) + (js2-export-binding-node-extern-name node)) + (if import-p + (js2-set-face (js2-current-token-beg) (js2-current-token-end) + 'font-lock-variable-name-face 'record)) + node) + (js2-unget-token) + nil)) + (let* ((name-node (make-js2-name-node + :name (js2-current-token-string) + :pos (js2-current-token-beg) + :len (js2-current-token-len))) + (node (make-js2-export-binding-node + :pos (js2-current-token-beg) + :len (js2-current-token-len) + :local-name name-node + :extern-name name-node))) + (when is-reserved-name + (js2-report-error "msg.mod.as.after.reserved.word" extern-name)) + (js2-node-add-children node name-node) + (if import-p + (js2-set-face (js2-current-token-beg) (js2-current-token-end) + 'font-lock-variable-name-face 'record)) + node)) + nil))) + +(defun js2-parse-switch () + "Parser for switch-statement. Last matched token must be js2-SWITCH." + (let ((pos (js2-current-token-beg)) + tt pn discriminant has-default case-expr case-node + case-pos cases stmt lp) + (if (js2-must-match js2-LP "msg.no.paren.switch") + (setq lp (js2-current-token-beg))) + (setq discriminant (js2-parse-expr) + pn (make-js2-switch-node :discriminant discriminant + :pos pos + :lp (js2-relpos lp pos))) + (js2-node-add-children pn discriminant) + (js2-enter-switch pn) + (unwind-protect + (progn + (if (js2-must-match js2-RP "msg.no.paren.after.switch") + (setf (js2-switch-node-rp pn) (- (js2-current-token-beg) pos))) + (js2-must-match js2-LC "msg.no.brace.switch") + (catch 'break + (while t + (setq tt (js2-next-token) + case-pos (js2-current-token-beg)) + (cond + ((= tt js2-RC) + (setf (js2-node-len pn) (- (js2-current-token-end) pos)) + (throw 'break nil)) ; done + ((= tt js2-CASE) + (setq case-expr (js2-parse-expr)) + (js2-must-match js2-COLON "msg.no.colon.case")) + ((= tt js2-DEFAULT) + (if has-default + (js2-report-error "msg.double.switch.default")) + (setq has-default t + case-expr nil) + (js2-must-match js2-COLON "msg.no.colon.case")) + (t + (js2-report-error "msg.bad.switch") + (throw 'break nil))) + (setq case-node (make-js2-case-node :pos case-pos + :len (- (js2-current-token-end) case-pos) + :expr case-expr)) + (js2-node-add-children case-node case-expr) + (while (and (/= (setq tt (js2-peek-token)) js2-RC) + (/= tt js2-CASE) + (/= tt js2-DEFAULT) + (/= tt js2-EOF)) + (setf stmt (js2-parse-statement) + (js2-node-len case-node) (- (js2-node-end stmt) case-pos)) + (js2-block-node-push case-node stmt)) + (push case-node cases))) + ;; add cases last, as pushing reverses the order to be correct + (dolist (kid cases) + (js2-node-add-children pn kid) + (push kid (js2-switch-node-cases pn))) + pn) ; return value + (js2-exit-switch)))) + +(defun js2-parse-while () + "Parser for while-statement. Last matched token must be js2-WHILE." + (let ((pos (js2-current-token-beg)) + (pn (make-js2-while-node)) + cond body) + (js2-enter-loop pn) + (unwind-protect + (progn + (setf cond (js2-parse-condition) + (js2-while-node-condition pn) (car cond) + body (js2-parse-statement) + (js2-while-node-body pn) body + (js2-node-len pn) (- (js2-node-end body) pos) + (js2-while-node-lp pn) (js2-relpos (cl-second cond) pos) + (js2-while-node-rp pn) (js2-relpos (cl-third cond) pos)) + (js2-node-add-children pn body (car cond))) + (js2-exit-loop)) + pn)) + +(defun js2-parse-do () + "Parser for do-statement. Last matched token must be js2-DO." + (let ((pos (js2-current-token-beg)) + (pn (make-js2-do-node)) + cond body end) + (js2-enter-loop pn) + (unwind-protect + (progn + (setq body (js2-parse-statement)) + (js2-must-match js2-WHILE "msg.no.while.do") + (setf (js2-do-node-while-pos pn) (- (js2-current-token-beg) pos) + cond (js2-parse-condition) + (js2-do-node-condition pn) (car cond) + (js2-do-node-body pn) body + end js2-ts-cursor + (js2-do-node-lp pn) (js2-relpos (cl-second cond) pos) + (js2-do-node-rp pn) (js2-relpos (cl-third cond) pos)) + (js2-node-add-children pn (car cond) body)) + (js2-exit-loop)) + ;; Always auto-insert semicolon to follow SpiderMonkey: + ;; It is required by ECMAScript but is ignored by the rest of + ;; world; see bug 238945 + (if (js2-match-token js2-SEMI) + (setq end js2-ts-cursor)) + (setf (js2-node-len pn) (- end pos)) + pn)) + +(defun js2-parse-export () + "Parse an export statement. +The Last matched token must be js2-EXPORT. Currently, the `default' and `expr' +expressions should only be either hoistable expressions (function or generator) +or assignment expressions, but there is no checking to enforce that and so it +will parse without error a small subset of +invalid export statements." + (unless (js2-ast-root-p js2-current-scope) + (js2-report-error "msg.mod.export.decl.at.top.level")) + (let ((beg (js2-current-token-beg)) + (children (list)) + exports-list from-clause declaration default) + (cond + ((js2-match-token js2-MUL) + (setq from-clause (js2-parse-from-clause)) + (when from-clause + (push from-clause children))) + ((js2-match-token js2-LC) + (setq exports-list (js2-parse-export-bindings)) + (when exports-list + (dolist (export exports-list) + (push export children))) + (when (js2-match-contextual-kwd "from") + (js2-unget-token) + (setq from-clause (js2-parse-from-clause)))) + ((js2-match-token js2-DEFAULT) + (setq default (cond ((js2-match-token js2-CLASS) + (if (eq (js2-peek-token) js2-NAME) + (js2-parse-class-stmt) + (js2-parse-class-expr))) + ((js2-match-token js2-NAME) + (if (js2-match-async-function) + (if (eq (js2-peek-token) js2-NAME) + (js2-parse-async-function-stmt) + (js2-parse-function-expr t)) + (js2-unget-token) + (js2-parse-expr))) + ((js2-match-token js2-FUNCTION) + (if (eq (js2-peek-token) js2-NAME) + (js2-parse-function-stmt) + (js2-parse-function-expr))) + (t (js2-parse-expr))))) + ((or (js2-match-token js2-VAR) (js2-match-token js2-CONST) (js2-match-token js2-LET)) + (setq declaration (js2-parse-variables (js2-current-token-type) (js2-current-token-beg)))) + ((js2-match-token js2-CLASS) + (setq declaration (js2-parse-class-stmt))) + ((js2-match-token js2-NAME) + (setq declaration + (if (js2-match-async-function) + (js2-parse-async-function-stmt) + (js2-unget-token) + (js2-parse-expr)))) + ((js2-match-token js2-FUNCTION) + (setq declaration (js2-parse-function-stmt))) + (t + (setq declaration (js2-parse-expr)))) + (when from-clause + (push from-clause children)) + (when declaration + (push declaration children) + (when (not (or (js2-function-node-p declaration) + (js2-class-node-p declaration))) + (js2-auto-insert-semicolon declaration))) + (when default + (push default children) + (when (not (or (js2-function-node-p default) + (js2-class-node-p default))) + (js2-auto-insert-semicolon default))) + (let ((node (make-js2-export-node + :pos beg + :len (- (js2-current-token-end) beg) + :exports-list exports-list + :from-clause from-clause + :declaration declaration + :default default))) + (apply #'js2-node-add-children node children) + node))) + +(defun js2-parse-for () + "Parse a for, for-in or for each-in statement. +Last matched token must be js2-FOR." + (let ((for-pos (js2-current-token-beg)) + (tmp-scope (make-js2-scope)) + pn is-for-each is-for-in-or-of is-for-of + in-pos each-pos tmp-pos + init ; Node init is also foo in 'foo in object'. + cond ; Node cond is also object in 'foo in object'. + incr ; 3rd section of for-loop initializer. + body tt lp rp) + ;; See if this is a for each () instead of just a for () + (when (js2-match-token js2-NAME) + (if (string= "each" (js2-current-token-string)) + (progn + (setq is-for-each t + each-pos (- (js2-current-token-beg) for-pos)) ; relative + (js2-record-face 'font-lock-keyword-face)) + (js2-report-error "msg.no.paren.for"))) + (if (js2-must-match js2-LP "msg.no.paren.for") + (setq lp (- (js2-current-token-beg) for-pos))) + (setq tt (js2-get-token)) + ;; Capture identifiers inside parens. We can't create the node + ;; (and use it as the current scope) until we know its type. + (js2-push-scope tmp-scope) + (unwind-protect + (progn + ;; parse init clause + (let ((js2-in-for-init t)) ; set as dynamic variable + (cond + ((= tt js2-SEMI) + (js2-unget-token) + (setq init (make-js2-empty-expr-node))) + ((or (= tt js2-VAR) (= tt js2-LET) (= tt js2-CONST)) + (setq init (js2-parse-variables tt (js2-current-token-beg)))) + (t + (js2-unget-token) + (setq init (js2-parse-expr))))) + (if (or (js2-match-token js2-IN) + (and (>= js2-language-version 200) + (js2-match-contextual-kwd "of") + (setq is-for-of t))) + (setq is-for-in-or-of t + in-pos (- (js2-current-token-beg) for-pos) + ;; scope of iteration target object is not the scope we've created above. + ;; stash current scope temporary. + cond (let ((js2-current-scope (js2-scope-parent-scope js2-current-scope))) + (js2-parse-expr))) ; object over which we're iterating + ;; else ordinary for loop - parse cond and incr + (js2-must-match js2-SEMI "msg.no.semi.for") + (setq cond (if (= (js2-peek-token) js2-SEMI) + (make-js2-empty-expr-node) ; no loop condition + (js2-parse-expr))) + (js2-must-match js2-SEMI "msg.no.semi.for.cond") + (setq tmp-pos (js2-current-token-end) + incr (if (= (js2-peek-token) js2-RP) + (make-js2-empty-expr-node :pos tmp-pos) + (js2-parse-expr))))) + (js2-pop-scope)) + (if (js2-must-match js2-RP "msg.no.paren.for.ctrl") + (setq rp (- (js2-current-token-beg) for-pos))) + (if (not is-for-in-or-of) + (setq pn (make-js2-for-node :init init + :condition cond + :update incr + :lp lp + :rp rp)) + ;; cond could be null if 'in obj' got eaten by the init node. + (if (js2-infix-node-p init) + ;; it was (foo in bar) instead of (var foo in bar) + (setq cond (js2-infix-node-right init) + init (js2-infix-node-left init)) + (if (and (js2-var-decl-node-p init) + (> (length (js2-var-decl-node-kids init)) 1)) + (js2-report-error "msg.mult.index"))) + (setq pn (make-js2-for-in-node :iterator init + :object cond + :in-pos in-pos + :foreach-p is-for-each + :each-pos each-pos + :forof-p is-for-of + :lp lp + :rp rp))) + ;; Transplant the declarations. + (setf (js2-scope-symbol-table pn) + (js2-scope-symbol-table tmp-scope)) + (unwind-protect + (progn + (js2-enter-loop pn) + ;; We have to parse the body -after- creating the loop node, + ;; so that the loop node appears in the js2-loop-set, allowing + ;; break/continue statements to find the enclosing loop. + (setf body (js2-parse-statement) + (js2-loop-node-body pn) body + (js2-node-pos pn) for-pos + (js2-node-len pn) (- (js2-node-end body) for-pos)) + (js2-node-add-children pn init cond incr body)) + ;; finally + (js2-exit-loop)) + pn)) + +(defun js2-parse-try () + "Parse a try statement. Last matched token must be js2-TRY." + (let ((try-pos (js2-current-token-beg)) + try-end + try-block + catch-blocks + finally-block + saw-default-catch + peek) + (if (/= (js2-peek-token) js2-LC) + (js2-report-error "msg.no.brace.try")) + (setq try-block (js2-parse-statement) + try-end (js2-node-end try-block) + peek (js2-peek-token)) + (cond + ((= peek js2-CATCH) + (while (js2-match-token js2-CATCH) + (let* ((catch-pos (js2-current-token-beg)) + (catch-node (make-js2-catch-node :pos catch-pos)) + param + guard-kwd + catch-cond + lp rp) + (if saw-default-catch + (js2-report-error "msg.catch.unreachable")) + (if (js2-must-match js2-LP "msg.no.paren.catch") + (setq lp (- (js2-current-token-beg) catch-pos))) + (js2-push-scope catch-node) + (let ((tt (js2-peek-token))) + (cond + ;; Destructuring pattern: + ;; catch ({ message, file }) { ... } + ((or (= tt js2-LB) (= tt js2-LC)) + (js2-get-token) + (setq param (js2-parse-destruct-primary-expr)) + (js2-define-destruct-symbols param js2-LET nil)) + ;; Simple name. + (t + (js2-must-match-name "msg.bad.catchcond") + (setq param (js2-create-name-node)) + (js2-define-symbol js2-LET (js2-current-token-string) param) + (js2-check-strict-identifier param)))) + ;; Catch condition. + (if (js2-match-token js2-IF) + (setq guard-kwd (- (js2-current-token-beg) catch-pos) + catch-cond (js2-parse-expr)) + (setq saw-default-catch t)) + (if (js2-must-match js2-RP "msg.bad.catchcond") + (setq rp (- (js2-current-token-beg) catch-pos))) + (js2-must-match js2-LC "msg.no.brace.catchblock") + (js2-parse-statements catch-node) + (if (js2-must-match js2-RC "msg.no.brace.after.body") + (setq try-end (js2-current-token-end))) + (js2-pop-scope) + (setf (js2-node-len catch-node) (- try-end catch-pos) + (js2-catch-node-param catch-node) param + (js2-catch-node-guard-expr catch-node) catch-cond + (js2-catch-node-guard-kwd catch-node) guard-kwd + (js2-catch-node-lp catch-node) lp + (js2-catch-node-rp catch-node) rp) + (js2-node-add-children catch-node param catch-cond) + (push catch-node catch-blocks)))) + ((/= peek js2-FINALLY) + (js2-must-match js2-FINALLY "msg.try.no.catchfinally" + (js2-node-pos try-block) + (- (setq try-end (js2-node-end try-block)) + (js2-node-pos try-block))))) + (when (js2-match-token js2-FINALLY) + (let ((finally-pos (js2-current-token-beg)) + (block (js2-parse-statement))) + (setq try-end (js2-node-end block) + finally-block (make-js2-finally-node :pos finally-pos + :len (- try-end finally-pos) + :body block)) + (js2-node-add-children finally-block block))) + (let ((pn (make-js2-try-node :pos try-pos + :len (- try-end try-pos) + :try-block try-block + :finally-block finally-block))) + (js2-node-add-children pn try-block finally-block) + ;; Push them onto the try-node, which reverses and corrects their order. + (dolist (cb catch-blocks) + (js2-node-add-children pn cb) + (push cb (js2-try-node-catch-clauses pn))) + pn))) + +(defun js2-parse-throw () + "Parser for throw-statement. Last matched token must be js2-THROW." + (let ((pos (js2-current-token-beg)) + expr pn) + (if (= (js2-peek-token-or-eol) js2-EOL) + ;; ECMAScript does not allow new lines before throw expression, + ;; see bug 256617 + (js2-report-error "msg.bad.throw.eol")) + (setq expr (js2-parse-expr) + pn (make-js2-throw-node :pos pos + :len (- (js2-node-end expr) pos) + :expr expr)) + (js2-node-add-children pn expr) + pn)) + +(defun js2-match-jump-label-name (label-name) + "If break/continue specified a label, return that label's labeled stmt. +Returns the corresponding `js2-labeled-stmt-node', or if LABEL-NAME +does not match an existing label, reports an error and returns nil." + (let ((bundle (cdr (assoc label-name js2-label-set)))) + (if (null bundle) + (js2-report-error "msg.undef.label")) + bundle)) + +(defun js2-parse-break () + "Parser for break-statement. Last matched token must be js2-BREAK." + (let ((pos (js2-current-token-beg)) + (end (js2-current-token-end)) + break-target ; statement to break from + break-label ; in "break foo", name-node representing the foo + labels ; matching labeled statement to break to + pn) + (when (eq (js2-peek-token-or-eol) js2-NAME) + (js2-get-token) + (setq break-label (js2-create-name-node) + end (js2-node-end break-label) + ;; matchJumpLabelName only matches if there is one + labels (js2-match-jump-label-name (js2-current-token-string)) + break-target (if labels (car (js2-labeled-stmt-node-labels labels))))) + (unless (or break-target break-label) + ;; no break target specified - try for innermost enclosing loop/switch + (if (null js2-loop-and-switch-set) + (unless break-label + (js2-report-error "msg.bad.break" nil pos (length "break"))) + (setq break-target (car js2-loop-and-switch-set)))) + (setq pn (make-js2-break-node :pos pos + :len (- end pos) + :label break-label + :target break-target)) + (js2-node-add-children pn break-label) ; but not break-target + pn)) + +(defun js2-parse-continue () + "Parser for continue-statement. Last matched token must be js2-CONTINUE." + (let ((pos (js2-current-token-beg)) + (end (js2-current-token-end)) + label ; optional user-specified label, a `js2-name-node' + labels ; current matching labeled stmt, if any + target ; the `js2-loop-node' target of this continue stmt + pn) + (when (= (js2-peek-token-or-eol) js2-NAME) + (js2-get-token) + (setq label (js2-create-name-node) + end (js2-node-end label) + ;; matchJumpLabelName only matches if there is one + labels (js2-match-jump-label-name (js2-current-token-string)))) + (cond + ((null labels) ; no current label to go to + (if (null js2-loop-set) ; no loop to continue to + (js2-report-error "msg.continue.outside" nil pos + (length "continue")) + (setq target (car js2-loop-set)))) ; innermost enclosing loop + (t + (if (js2-loop-node-p (js2-labeled-stmt-node-stmt labels)) + (setq target (js2-labeled-stmt-node-stmt labels)) + (js2-report-error "msg.continue.nonloop" nil pos (- end pos))))) + (setq pn (make-js2-continue-node :pos pos + :len (- end pos) + :label label + :target target)) + (js2-node-add-children pn label) ; but not target - it's not our child + pn)) + +(defun js2-parse-with () + "Parser for with-statement. Last matched token must be js2-WITH." + (when js2-in-use-strict-directive + (js2-report-error "msg.no.with.strict")) + (let ((pos (js2-current-token-beg)) + obj body pn lp rp) + (if (js2-must-match js2-LP "msg.no.paren.with") + (setq lp (js2-current-token-beg))) + (setq obj (js2-parse-expr)) + (if (js2-must-match js2-RP "msg.no.paren.after.with") + (setq rp (js2-current-token-beg))) + (let ((js2-nesting-of-with (1+ js2-nesting-of-with))) + (setq body (js2-parse-statement))) + (setq pn (make-js2-with-node :pos pos + :len (- (js2-node-end body) pos) + :object obj + :body body + :lp (js2-relpos lp pos) + :rp (js2-relpos rp pos))) + (js2-node-add-children pn obj body) + pn)) + +(defun js2-parse-const-var () + "Parser for var- or const-statement. +Last matched token must be js2-CONST or js2-VAR." + (let ((tt (js2-current-token-type)) + (pos (js2-current-token-beg)) + expr pn) + (setq expr (js2-parse-variables tt (js2-current-token-beg)) + pn (make-js2-expr-stmt-node :pos pos + :len (- (js2-node-end expr) pos) + :expr expr)) + (js2-node-add-children pn expr) + pn)) + +(defun js2-wrap-with-expr-stmt (pos expr &optional add-child) + (let ((pn (make-js2-expr-stmt-node :pos pos + :len (js2-node-len expr) + :type (if (js2-inside-function) + js2-EXPR_VOID + js2-EXPR_RESULT) + :expr expr))) + (if add-child + (js2-node-add-children pn expr)) + pn)) + +(defun js2-parse-let-stmt () + "Parser for let-statement. Last matched token must be js2-LET." + (let ((pos (js2-current-token-beg)) + expr pn) + (if (= (js2-peek-token) js2-LP) + ;; let expression in statement context + (setq expr (js2-parse-let pos 'statement) + pn (js2-wrap-with-expr-stmt pos expr t)) + ;; else we're looking at a statement like let x=6, y=7; + (setf expr (js2-parse-variables js2-LET pos) + pn (js2-wrap-with-expr-stmt pos expr t) + (js2-node-type pn) js2-EXPR_RESULT)) + pn)) + +(defun js2-parse-ret-yield () + (js2-parse-return-or-yield (js2-current-token-type) nil)) + +(defconst js2-parse-return-stmt-enders + (list js2-SEMI js2-RC js2-EOF js2-EOL js2-ERROR js2-RB js2-RP)) + +(defsubst js2-now-all-set (before after mask) + "Return whether or not the bits in the mask have changed to all set. +BEFORE is bits before change, AFTER is bits after change, and MASK is +the mask for bits. Returns t if all the bits in the mask are set in AFTER +but not BEFORE." + (and (/= (logand before mask) mask) + (= (logand after mask) mask))) + +(defun js2-parse-return-or-yield (tt expr-context) + (let* ((pos (js2-current-token-beg)) + (end (js2-current-token-end)) + (before js2-end-flags) + (inside-function (js2-inside-function)) + (gen-type (and inside-function (js2-function-node-generator-type + js2-current-script-or-fn))) + e ret name yield-star-p) + (unless inside-function + (js2-report-error (if (eq tt js2-RETURN) + "msg.bad.return" + "msg.bad.yield"))) + (when (and inside-function + (eq gen-type 'STAR) + (js2-match-token js2-MUL)) + (setq yield-star-p t)) + ;; This is ugly, but we don't want to require a semicolon. + (unless (memq (js2-peek-token-or-eol) js2-parse-return-stmt-enders) + (setq e (if (eq gen-type 'STAR) + (js2-parse-assign-expr) + (js2-parse-expr)) + end (js2-node-end e))) + (cond + ((eq tt js2-RETURN) + (js2-set-flag js2-end-flags (if (null e) + js2-end-returns + js2-end-returns-value)) + (setq ret (make-js2-return-node :pos pos + :len (- end pos) + :retval e)) + (js2-node-add-children ret e) + ;; See if we need a strict mode warning. + ;; TODO: The analysis done by `js2-has-consistent-return-usage' is + ;; more thorough and accurate than this before/after flag check. + ;; E.g. if there's a finally-block that always returns, we shouldn't + ;; show a warning generated by inconsistent returns in the catch blocks. + ;; Basically `js2-has-consistent-return-usage' needs to keep more state, + ;; so we know which returns/yields to highlight, and we should get rid of + ;; all the checking in `js2-parse-return-or-yield'. + (if (and js2-strict-inconsistent-return-warning + (js2-now-all-set before js2-end-flags + (logior js2-end-returns js2-end-returns-value))) + (js2-add-strict-warning "msg.return.inconsistent" nil pos end))) + ((eq gen-type 'COMPREHENSION) + ;; FIXME: We should probably switch to saving and using lastYieldOffset, + ;; like SpiderMonkey does. + (js2-report-error "msg.syntax" nil pos 5)) + (t + (setq ret (make-js2-yield-node :pos pos + :len (- end pos) + :value e + :star-p yield-star-p)) + (js2-node-add-children ret e) + (unless expr-context + (setq e ret + ret (js2-wrap-with-expr-stmt pos e t)) + (js2-set-requires-activation) + (js2-set-is-generator)))) + ;; see if we are mixing yields and value returns. + (when (and inside-function + (js2-flag-set-p js2-end-flags js2-end-returns-value) + (eq (js2-function-node-generator-type js2-current-script-or-fn) + 'LEGACY)) + (setq name (js2-function-name js2-current-script-or-fn)) + (if (zerop (length name)) + (js2-report-error "msg.anon.generator.returns" nil pos (- end pos)) + (js2-report-error "msg.generator.returns" name pos (- end pos)))) + ret)) + +(defun js2-parse-debugger () + (make-js2-keyword-node :type js2-DEBUGGER)) + +(defun js2-parse-block () + "Parser for a curly-delimited statement block. +Last token matched must be `js2-LC'." + (let ((pos (js2-current-token-beg)) + (pn (make-js2-scope))) + (js2-push-scope pn) + (unwind-protect + (progn + (js2-parse-statements pn) + (js2-must-match js2-RC "msg.no.brace.block") + (setf (js2-node-len pn) (- (js2-current-token-end) pos))) + (js2-pop-scope)) + pn)) + +;; For `js2-ERROR' too, to have a node for error recovery to work on. +(defun js2-parse-semi () + "Parse a statement or handle an error. +Current token type is `js2-SEMI' or `js2-ERROR'." + (let ((tt (js2-current-token-type)) pos len) + (if (eq tt js2-SEMI) + (make-js2-empty-expr-node :len 1) + (setq pos (js2-current-token-beg) + len (- (js2-current-token-end) pos)) + (js2-report-error "msg.syntax" nil pos len) + (make-js2-error-node :pos pos :len len)))) + +(defun js2-parse-default-xml-namespace () + "Parse a `default xml namespace = <expr>' e4x statement." + (let ((pos (js2-current-token-beg)) + end len expr unary) + (js2-must-have-xml) + (js2-set-requires-activation) + (setq len (- js2-ts-cursor pos)) + (unless (and (js2-match-token js2-NAME) + (string= (js2-current-token-string) "xml")) + (js2-report-error "msg.bad.namespace" nil pos len)) + (unless (and (js2-match-token js2-NAME) + (string= (js2-current-token-string) "namespace")) + (js2-report-error "msg.bad.namespace" nil pos len)) + (unless (js2-match-token js2-ASSIGN) + (js2-report-error "msg.bad.namespace" nil pos len)) + (setq expr (js2-parse-expr) + end (js2-node-end expr) + unary (make-js2-unary-node :type js2-DEFAULTNAMESPACE + :pos pos + :len (- end pos) + :operand expr)) + (js2-node-add-children unary expr) + (make-js2-expr-stmt-node :pos pos + :len (- end pos) + :expr unary))) + +(defun js2-record-label (label bundle) + ;; current token should be colon that `js2-parse-primary-expr' left untouched + (js2-get-token) + (let ((name (js2-label-node-name label)) + labeled-stmt + dup) + (when (setq labeled-stmt (cdr (assoc name js2-label-set))) + ;; flag both labels if possible when used in editing mode + (if (and js2-parse-ide-mode + (setq dup (js2-get-label-by-name labeled-stmt name))) + (js2-report-error "msg.dup.label" nil + (js2-node-abs-pos dup) (js2-node-len dup))) + (js2-report-error "msg.dup.label" nil + (js2-node-pos label) (js2-node-len label))) + (js2-labeled-stmt-node-add-label bundle label) + (js2-node-add-children bundle label) + ;; Add one reference to the bundle per label in `js2-label-set' + (push (cons name bundle) js2-label-set))) + +(defun js2-parse-name-or-label () + "Parser for identifier or label. Last token matched must be js2-NAME. +Called when we found a name in a statement context. If it's a label, we gather +up any following labels and the next non-label statement into a +`js2-labeled-stmt-node' bundle and return that. Otherwise we parse an +expression and return it wrapped in a `js2-expr-stmt-node'." + (let ((pos (js2-current-token-beg)) + expr stmt bundle + (continue t)) + ;; set check for label and call down to `js2-parse-primary-expr' + (setq expr (js2-maybe-parse-label)) + (if (null expr) + ;; Parse the non-label expression and wrap with expression stmt. + (js2-wrap-with-expr-stmt pos (js2-parse-expr) t) + ;; else parsed a label + (setq bundle (make-js2-labeled-stmt-node :pos pos)) + (js2-record-label expr bundle) + ;; look for more labels + (while (and continue (= (js2-get-token) js2-NAME)) + (if (setq expr (js2-maybe-parse-label)) + (js2-record-label expr bundle) + (setq expr (js2-parse-expr) + stmt (js2-wrap-with-expr-stmt (js2-node-pos expr) expr t) + continue nil) + (js2-auto-insert-semicolon stmt))) + ;; no more labels; now parse the labeled statement + (unwind-protect + (unless stmt + (let ((js2-labeled-stmt bundle)) ; bind dynamically + (js2-unget-token) + (setq stmt (js2-statement-helper)))) + ;; remove the labels for this statement from the global set + (dolist (label (js2-labeled-stmt-node-labels bundle)) + (setq js2-label-set (remove label js2-label-set)))) + (setf (js2-labeled-stmt-node-stmt bundle) stmt + (js2-node-len bundle) (- (js2-node-end stmt) pos)) + (js2-node-add-children bundle stmt) + bundle))) + +(defun js2-maybe-parse-label () + (cl-assert (= (js2-current-token-type) js2-NAME)) + (let (label-pos + (next-tt (js2-get-token)) + (label-end (js2-current-token-end))) + ;; Do not consume colon, it is used as unwind indicator + ;; to return to statementHelper. + (js2-unget-token) + (if (= next-tt js2-COLON) + (prog2 + (setq label-pos (js2-current-token-beg)) + (make-js2-label-node :pos label-pos + :len (- label-end label-pos) + :name (js2-current-token-string)) + (js2-set-face label-pos + label-end + 'font-lock-variable-name-face 'record)) + ;; Backtrack from the name token, too. + (js2-unget-token) + nil))) + +(defun js2-parse-expr-stmt () + "Default parser in statement context, if no recognized statement found." + (js2-wrap-with-expr-stmt (js2-current-token-beg) + (progn + (js2-unget-token) + (js2-parse-expr)) t)) + +(defun js2-parse-variables (decl-type pos) + "Parse a comma-separated list of variable declarations. +Could be a `var', `const' or `let' expression, possibly in a for-loop initializer. + +DECL-TYPE is a token value: either VAR, CONST, or LET depending on context. +For `var' or `const', the keyword should be the token last scanned. + +POS is the position where the node should start. It's sometimes the +var/const/let keyword, and other times the beginning of the first token +in the first variable declaration. + +Returns the parsed `js2-var-decl-node' expression node." + (let* ((result (make-js2-var-decl-node :decl-type decl-type + :pos pos)) + destructuring kid-pos tt init name end nbeg nend vi + (continue t)) + ;; Example: + ;; var foo = {a: 1, b: 2}, bar = [3, 4]; + ;; var {b: s2, a: s1} = foo, x = 6, y, [s3, s4] = bar; + ;; var {a, b} = baz; + (while continue + (setq destructuring nil + name nil + tt (js2-get-token) + kid-pos (js2-current-token-beg) + end (js2-current-token-end) + init nil) + (if (or (= tt js2-LB) (= tt js2-LC)) + ;; Destructuring assignment, e.g., var [a, b] = ... + (setq destructuring (js2-parse-destruct-primary-expr) + end (js2-node-end destructuring)) + ;; Simple variable name + (js2-unget-token) + (when (js2-must-match-name "msg.bad.var") + (setq name (js2-create-name-node) + nbeg (js2-current-token-beg) + nend (js2-current-token-end) + end nend) + (js2-define-symbol decl-type (js2-current-token-string) name js2-in-for-init) + (js2-check-strict-identifier name))) + (when (js2-match-token js2-ASSIGN) + (setq init (js2-parse-assign-expr) + end (js2-node-end init)) + (js2-record-imenu-functions init name)) + (when name + (js2-set-face nbeg nend (if (js2-function-node-p init) + 'font-lock-function-name-face + 'font-lock-variable-name-face) + 'record)) + (setq vi (make-js2-var-init-node :pos kid-pos + :len (- end kid-pos) + :type decl-type)) + (if destructuring + (progn + (if (and (null init) (not js2-in-for-init)) + (js2-report-error "msg.destruct.assign.no.init")) + (js2-define-destruct-symbols destructuring + decl-type + 'font-lock-variable-name-face) + (setf (js2-var-init-node-target vi) destructuring)) + (setf (js2-var-init-node-target vi) name)) + (setf (js2-var-init-node-initializer vi) init) + (js2-node-add-children vi name destructuring init) + (js2-block-node-push result vi) + (unless (js2-match-token js2-COMMA) + (setq continue nil))) + (setf (js2-node-len result) (- end pos)) + result)) + +(defun js2-parse-let (pos &optional stmt-p) + "Parse a let expression or statement. +A let-expression is of the form `let (vars) expr'. +A let-statement is of the form `let (vars) {statements}'. +The third form of let is a variable declaration list, handled +by `js2-parse-variables'." + (let ((pn (make-js2-let-node :pos pos)) + beg vars body) + (if (js2-must-match js2-LP "msg.no.paren.after.let") + (setf (js2-let-node-lp pn) (- (js2-current-token-beg) pos))) + (js2-push-scope pn) + (unwind-protect + (progn + (setq vars (js2-parse-variables js2-LET (js2-current-token-beg))) + (if (js2-must-match js2-RP "msg.no.paren.let") + (setf (js2-let-node-rp pn) (- (js2-current-token-beg) pos))) + (if (and stmt-p (js2-match-token js2-LC)) + ;; let statement + (progn + (setf beg (js2-current-token-beg) ; position stmt at LC + body (js2-parse-statements)) + (js2-must-match js2-RC "msg.no.curly.let") + (setf (js2-node-len body) (- (js2-current-token-end) beg) + (js2-node-len pn) (- (js2-current-token-end) pos) + (js2-let-node-body pn) body + (js2-node-type pn) js2-LET)) + ;; let expression + (setf body (js2-parse-expr) + (js2-node-len pn) (- (js2-node-end body) pos) + (js2-let-node-body pn) body)) + (setf (js2-let-node-vars pn) vars) + (js2-node-add-children pn vars body)) + (js2-pop-scope)) + pn)) + +(defun js2-define-new-symbol (decl-type name node &optional scope) + (js2-scope-put-symbol (or scope js2-current-scope) + name + (make-js2-symbol decl-type name node))) + +(defun js2-define-symbol (decl-type name &optional node ignore-not-in-block) + "Define a symbol in the current scope. +If NODE is non-nil, it is the AST node associated with the symbol." + (let* ((defining-scope (js2-get-defining-scope js2-current-scope name)) + (symbol (if defining-scope + (js2-scope-get-symbol defining-scope name))) + (sdt (if symbol (js2-symbol-decl-type symbol) -1)) + (pos (if node (js2-node-abs-pos node))) + (len (if node (js2-node-len node)))) + (cond + ((and symbol ; already defined in this block + (or (= sdt js2-LET) + (= sdt js2-CONST)) + (eq defining-scope js2-current-scope)) + (js2-report-error + (cond + ((= sdt js2-CONST) "msg.const.redecl") + ((= sdt js2-LET) "msg.let.redecl") + ((= sdt js2-VAR) "msg.var.redecl") + ((= sdt js2-FUNCTION) "msg.function.redecl") + (t "msg.parm.redecl")) + name pos len)) + ((or (= decl-type js2-LET) + (= decl-type js2-CONST)) + (if (and (= decl-type js2-LET) + (not ignore-not-in-block) + (or (= (js2-node-type js2-current-scope) js2-IF) + (js2-loop-node-p js2-current-scope))) + (js2-report-error "msg.let.decl.not.in.block") + (js2-define-new-symbol decl-type name node))) + ((or (= decl-type js2-VAR) + (= decl-type js2-FUNCTION)) + (if symbol + (if (and js2-strict-var-redeclaration-warning (= sdt js2-VAR)) + (js2-add-strict-warning "msg.var.redecl" name) + (if (and js2-strict-var-hides-function-arg-warning (= sdt js2-LP)) + (js2-add-strict-warning "msg.var.hides.arg" name))) + (js2-define-new-symbol decl-type name node + js2-current-script-or-fn))) + ((= decl-type js2-LP) + (if symbol + ;; must be duplicate parameter. Second parameter hides the + ;; first, so go ahead and add the second pararameter + (js2-report-warning "msg.dup.parms" name)) + (js2-define-new-symbol decl-type name node)) + (t (js2-code-bug))))) + +(defun js2-parse-paren-expr-or-generator-comp () + (let ((px-pos (js2-current-token-beg))) + (cond + ((and (>= js2-language-version 200) + (js2-match-token js2-FOR)) + (js2-parse-generator-comp px-pos)) + ((and (>= js2-language-version 200) + (js2-match-token js2-RP)) + ;; Not valid expression syntax, but this is valid in an arrow + ;; function with no params: () => body. + (if (eq (js2-peek-token) js2-ARROW) + ;; Return whatever, it will hopefully be rewinded and + ;; reparsed when we reach the =>. + (make-js2-keyword-node :type js2-NULL) + (js2-report-error "msg.syntax") + (make-js2-error-node))) + (t + (let* ((js2-in-for-init nil) + (expr (js2-parse-expr)) + (pn (make-js2-paren-node :pos px-pos + :expr expr))) + (js2-node-add-children pn (js2-paren-node-expr pn)) + (js2-must-match js2-RP "msg.no.paren") + (setf (js2-node-len pn) (- (js2-current-token-end) px-pos)) + pn))))) + +(defun js2-parse-expr (&optional oneshot) + (let* ((pn (js2-parse-assign-expr)) + (pos (js2-node-pos pn)) + left + right + op-pos) + (while (and (not oneshot) + (js2-match-token js2-COMMA)) + (setq op-pos (- (js2-current-token-beg) pos)) ; relative + (setq right (js2-parse-assign-expr) + left pn + pn (make-js2-infix-node :type js2-COMMA + :pos pos + :len (- js2-ts-cursor pos) + :op-pos op-pos + :left left + :right right)) + (js2-node-add-children pn left right)) + pn)) + +(defun js2-parse-assign-expr () + (let ((tt (js2-get-token)) + (pos (js2-current-token-beg)) + pn left right op-pos + ts-state recorded-identifiers parsed-errors + async-p) + (if (= tt js2-YIELD) + (js2-parse-return-or-yield tt t) + ;; TODO(mooz): Bit confusing. + ;; If we meet `async` token and it's not part of `async + ;; function`, then this `async` is for a succeeding async arrow + ;; function. + ;; Since arrow function parsing doesn't rely on neither + ;; `js2-parse-function-stmt' nor `js2-parse-function-expr' that + ;; interpret `async` token, we trash `async` and just remember + ;; we met `async` keyword to `async-p'. + (when (js2-match-async-arrow-function) + (setq async-p t)) + ;; Save the tokenizer state in case we find an arrow function + ;; and have to rewind. + (setq ts-state (make-js2-ts-state) + recorded-identifiers js2-recorded-identifiers + parsed-errors js2-parsed-errors) + ;; not yield - parse assignment expression + (setq pn (js2-parse-cond-expr) + tt (js2-get-token)) + (cond + ((and (<= js2-first-assign tt) + (<= tt js2-last-assign)) + ;; tt express assignment (=, |=, ^=, ..., %=) + (setq op-pos (- (js2-current-token-beg) pos) ; relative + left pn) + ;; The assigned node could be a js2-prop-get-node (foo.bar = 0), we only + ;; care about assignment to strict variable names. + (when (js2-name-node-p left) + (js2-check-strict-identifier left)) + (setq right (js2-parse-assign-expr) + pn (make-js2-assign-node :type tt + :pos pos + :len (- (js2-node-end right) pos) + :op-pos op-pos + :left left + :right right)) + (when js2-parse-ide-mode + (js2-highlight-assign-targets pn left right) + (js2-record-imenu-functions right left)) + ;; do this last so ide checks above can use absolute positions + (js2-node-add-children pn left right)) + ((and (>= js2-language-version 200) + (or + (= tt js2-ARROW) + (and async-p + (= (js2-peek-token) js2-ARROW)))) + (js2-ts-seek ts-state) + (when async-p + (js2-record-face 'font-lock-keyword-face) + (js2-get-token)) + (setq js2-recorded-identifiers recorded-identifiers + js2-parsed-errors parsed-errors) + (setq pn (js2-parse-function 'FUNCTION_ARROW (js2-current-token-beg) nil async-p))) + (t + (js2-unget-token))) + pn))) + +(defun js2-parse-cond-expr () + (let ((pos (js2-current-token-beg)) + (pn (js2-parse-or-expr)) + test-expr + if-true + if-false + q-pos + c-pos) + (when (js2-match-token js2-HOOK) + (setq q-pos (- (js2-current-token-beg) pos) + if-true (let (js2-in-for-init) (js2-parse-assign-expr))) + (js2-must-match js2-COLON "msg.no.colon.cond") + (setq c-pos (- (js2-current-token-beg) pos) + if-false (js2-parse-assign-expr) + test-expr pn + pn (make-js2-cond-node :pos pos + :len (- (js2-node-end if-false) pos) + :test-expr test-expr + :true-expr if-true + :false-expr if-false + :q-pos q-pos + :c-pos c-pos)) + (js2-node-add-children pn test-expr if-true if-false)) + pn)) + +(defun js2-make-binary (type left parser &optional no-get) + "Helper for constructing a binary-operator AST node. +LEFT is the left-side-expression, already parsed, and the +binary operator should have just been matched. +PARSER is a function to call to parse the right operand, +or a `js2-node' struct if it has already been parsed. +FIXME: The latter option is unused?" + (let* ((pos (js2-node-pos left)) + (op-pos (- (js2-current-token-beg) pos)) + (right (if (js2-node-p parser) + parser + (unless no-get (js2-get-token)) + (funcall parser))) + (pn (make-js2-infix-node :type type + :pos pos + :len (- (js2-node-end right) pos) + :op-pos op-pos + :left left + :right right))) + (js2-node-add-children pn left right) + pn)) + +(defun js2-parse-or-expr () + (let ((pn (js2-parse-and-expr))) + (when (js2-match-token js2-OR) + (setq pn (js2-make-binary js2-OR + pn + 'js2-parse-or-expr))) + pn)) + +(defun js2-parse-and-expr () + (let ((pn (js2-parse-bit-or-expr))) + (when (js2-match-token js2-AND) + (setq pn (js2-make-binary js2-AND + pn + 'js2-parse-and-expr))) + pn)) + +(defun js2-parse-bit-or-expr () + (let ((pn (js2-parse-bit-xor-expr))) + (while (js2-match-token js2-BITOR) + (setq pn (js2-make-binary js2-BITOR + pn + 'js2-parse-bit-xor-expr))) + pn)) + +(defun js2-parse-bit-xor-expr () + (let ((pn (js2-parse-bit-and-expr))) + (while (js2-match-token js2-BITXOR) + (setq pn (js2-make-binary js2-BITXOR + pn + 'js2-parse-bit-and-expr))) + pn)) + +(defun js2-parse-bit-and-expr () + (let ((pn (js2-parse-eq-expr))) + (while (js2-match-token js2-BITAND) + (setq pn (js2-make-binary js2-BITAND + pn + 'js2-parse-eq-expr))) + pn)) + +(defconst js2-parse-eq-ops + (list js2-EQ js2-NE js2-SHEQ js2-SHNE)) + +(defun js2-parse-eq-expr () + (let ((pn (js2-parse-rel-expr)) + tt) + (while (memq (setq tt (js2-get-token)) js2-parse-eq-ops) + (setq pn (js2-make-binary tt + pn + 'js2-parse-rel-expr))) + (js2-unget-token) + pn)) + +(defconst js2-parse-rel-ops + (list js2-IN js2-INSTANCEOF js2-LE js2-LT js2-GE js2-GT)) + +(defun js2-parse-rel-expr () + (let ((pn (js2-parse-shift-expr)) + (continue t) + tt) + (while continue + (setq tt (js2-get-token)) + (cond + ((and js2-in-for-init (= tt js2-IN)) + (js2-unget-token) + (setq continue nil)) + ((memq tt js2-parse-rel-ops) + (setq pn (js2-make-binary tt pn 'js2-parse-shift-expr))) + (t + (js2-unget-token) + (setq continue nil)))) + pn)) + +(defconst js2-parse-shift-ops + (list js2-LSH js2-URSH js2-RSH)) + +(defun js2-parse-shift-expr () + (let ((pn (js2-parse-add-expr)) + tt + (continue t)) + (while continue + (setq tt (js2-get-token)) + (if (memq tt js2-parse-shift-ops) + (setq pn (js2-make-binary tt pn 'js2-parse-add-expr)) + (js2-unget-token) + (setq continue nil))) + pn)) + +(defun js2-parse-add-expr () + (let ((pn (js2-parse-mul-expr)) + tt + (continue t)) + (while continue + (setq tt (js2-get-token)) + (if (or (= tt js2-ADD) (= tt js2-SUB)) + (setq pn (js2-make-binary tt pn 'js2-parse-mul-expr)) + (js2-unget-token) + (setq continue nil))) + pn)) + +(defconst js2-parse-mul-ops + (list js2-MUL js2-DIV js2-MOD)) + +(defun js2-parse-mul-expr () + (let ((pn (js2-parse-expon-expr)) + tt + (continue t)) + (while continue + (setq tt (js2-get-token)) + (if (memq tt js2-parse-mul-ops) + (setq pn (js2-make-binary tt pn 'js2-parse-expon-expr)) + (js2-unget-token) + (setq continue nil))) + pn)) + +(defun js2-parse-expon-expr () + (let ((pn (js2-parse-unary-expr))) + (when (>= js2-language-version 200) + (while (js2-match-token js2-EXPON) + (when (and (js2-unary-node-p pn) + (not (memq (js2-node-type pn) '(js2-INC js2-DEC)))) + (js2-report-error "msg.syntax" nil + (js2-node-abs-pos pn) (js2-node-len pn))) + ;; Make it right-associative. + (setq pn (js2-make-binary js2-EXPON pn 'js2-parse-expon-expr)))) + pn)) + +(defun js2-make-unary (beg type parser &rest args) + "Make a unary node starting at BEG of type TYPE. +If BEG is nil, `(js2-current-token-beg)' is used for the node +start position. PARSER is either a node (for postfix operators) +or a function to call to parse the operand (for prefix +operators)." + (let* ((pos (or beg (js2-current-token-beg))) + (postfix (js2-node-p parser)) + (expr (if postfix + parser + (apply parser args))) + end + pn) + (if postfix ; e.g. i++ + (setq pos (js2-node-pos expr) + end (js2-current-token-end)) + (setq end (js2-node-end expr))) + (setq pn (make-js2-unary-node :type type + :pos pos + :len (- end pos) + :operand expr)) + (js2-node-add-children pn expr) + pn)) + +(defconst js2-incrementable-node-types + (list js2-NAME js2-GETPROP js2-GETELEM js2-GET_REF js2-CALL) + "Node types that can be the operand of a ++ or -- operator.") + +(defun js2-check-bad-inc-dec (tt beg end unary) + (unless (memq (js2-node-type (js2-unary-node-operand unary)) + js2-incrementable-node-types) + (js2-report-error (if (= tt js2-INC) + "msg.bad.incr" + "msg.bad.decr") + nil beg (- end beg)))) + +(defun js2-parse-unary-expr () + (let ((tt (js2-current-token-type)) + (beg (js2-current-token-beg))) + (cond + ((or (= tt js2-VOID) + (= tt js2-NOT) + (= tt js2-BITNOT) + (= tt js2-TYPEOF)) + (js2-get-token) + (js2-make-unary beg tt 'js2-parse-unary-expr)) + ((= tt js2-ADD) + (js2-get-token) + ;; Convert to special POS token in decompiler and parse tree + (js2-make-unary beg js2-POS 'js2-parse-unary-expr)) + ((= tt js2-SUB) + (js2-get-token) + ;; Convert to special NEG token in decompiler and parse tree + (js2-make-unary beg js2-NEG 'js2-parse-unary-expr)) + ((or (= tt js2-INC) + (= tt js2-DEC)) + (js2-get-token) + (let ((beg2 (js2-current-token-beg)) + (end (js2-current-token-end)) + (expr (js2-make-unary beg tt 'js2-parse-member-expr t))) + (js2-check-bad-inc-dec tt beg2 end expr) + expr)) + ((= tt js2-DELPROP) + (js2-get-token) + (js2-make-unary beg js2-DELPROP 'js2-parse-unary-expr)) + ((js2-parse-await-maybe tt)) + ((= tt js2-ERROR) + (js2-get-token) + (make-js2-error-node)) ; try to continue + ((and (= tt js2-LT) + js2-compiler-xml-available) + ;; XML stream encountered in expression. + (js2-parse-member-expr-tail t (js2-parse-xml-initializer))) + (t + (let ((pn (js2-parse-member-expr t)) + ;; Don't look across a newline boundary for a postfix incop. + (tt (js2-peek-token-or-eol)) + expr) + (when (or (= tt js2-INC) (= tt js2-DEC)) + (js2-get-token) + (setf expr pn + pn (js2-make-unary (js2-node-pos expr) tt expr)) + (js2-node-set-prop pn 'postfix t) + (js2-check-bad-inc-dec tt (js2-current-token-beg) (js2-current-token-end) pn)) + pn))))) + +(defun js2-parse-xml-initializer () + "Parse an E4X XML initializer. +I'm parsing it the way Rhino parses it, but without the tree-rewriting. +Then I'll postprocess the result, depending on whether we're in IDE +mode or codegen mode, and generate the appropriate rewritten AST. +IDE mode uses a rich AST that models the XML structure. Codegen mode +just concatenates everything and makes a new XML or XMLList out of it." + (let ((tt (js2-get-first-xml-token)) + pn-xml pn expr kids expr-pos + (continue t) + (first-token t)) + (when (not (or (= tt js2-XML) (= tt js2-XMLEND))) + (js2-report-error "msg.syntax")) + (setq pn-xml (make-js2-xml-node)) + (while continue + (if first-token + (setq first-token nil) + (setq tt (js2-get-next-xml-token))) + (cond + ;; js2-XML means we found a {expr} in the XML stream. + ;; The token string is the XML up to the left-curly. + ((= tt js2-XML) + (push (make-js2-string-node :pos (js2-current-token-beg) + :len (- js2-ts-cursor (js2-current-token-beg))) + kids) + (js2-must-match js2-LC "msg.syntax") + (setq expr-pos js2-ts-cursor + expr (if (eq (js2-peek-token) js2-RC) + (make-js2-empty-expr-node :pos expr-pos) + (js2-parse-expr))) + (js2-must-match js2-RC "msg.syntax") + (setq pn (make-js2-xml-js-expr-node :pos (js2-node-pos expr) + :len (js2-node-len expr) + :expr expr)) + (js2-node-add-children pn expr) + (push pn kids)) + ;; a js2-XMLEND token means we hit the final close-tag. + ((= tt js2-XMLEND) + (push (make-js2-string-node :pos (js2-current-token-beg) + :len (- js2-ts-cursor (js2-current-token-beg))) + kids) + (dolist (kid (nreverse kids)) + (js2-block-node-push pn-xml kid)) + (setf (js2-node-len pn-xml) (- js2-ts-cursor + (js2-node-pos pn-xml)) + continue nil)) + (t + (js2-report-error "msg.syntax") + (setq continue nil)))) + pn-xml)) + + +(defun js2-parse-argument-list () + "Parse an argument list and return it as a Lisp list of nodes. +Returns the list in reverse order. Consumes the right-paren token." + (let (result) + (unless (js2-match-token js2-RP) + (cl-loop do + (let ((tt (js2-get-token)) + (beg (js2-current-token-beg))) + (if (and (= tt js2-TRIPLEDOT) + (>= js2-language-version 200)) + (push (js2-make-unary beg tt 'js2-parse-assign-expr) result) + (js2-unget-token) + (push (js2-parse-assign-expr) result))) + while + (and (js2-match-token js2-COMMA) + (or (< js2-language-version 200) + (not (= js2-RP (js2-peek-token)))))) + (js2-must-match js2-RP "msg.no.paren.arg") + result))) + +(defun js2-parse-member-expr (&optional allow-call-syntax) + (let ((tt (js2-current-token-type)) + pn pos target args beg end init) + (if (/= tt js2-NEW) + (setq pn (js2-parse-primary-expr)) + ;; parse a 'new' expression + (js2-get-token) + (setq pos (js2-current-token-beg) + beg pos + target (js2-parse-member-expr) + end (js2-node-end target) + pn (make-js2-new-node :pos pos + :target target + :len (- end pos))) + (js2-highlight-function-call (js2-current-token)) + (js2-node-add-children pn target) + (when (js2-match-token js2-LP) + ;; Add the arguments to pn, if any are supplied. + (setf beg pos ; start of "new" keyword + pos (js2-current-token-beg) + args (nreverse (js2-parse-argument-list)) + (js2-new-node-args pn) args + end (js2-current-token-end) + (js2-new-node-lp pn) (- pos beg) + (js2-new-node-rp pn) (- end 1 beg)) + (apply #'js2-node-add-children pn args)) + (when (and js2-allow-rhino-new-expr-initializer + (js2-match-token js2-LC)) + (setf init (js2-parse-object-literal) + end (js2-node-end init) + (js2-new-node-initializer pn) init) + (js2-node-add-children pn init)) + (setf (js2-node-len pn) (- end beg))) ; end outer if + (js2-parse-member-expr-tail allow-call-syntax pn))) + +(defun js2-parse-member-expr-tail (allow-call-syntax pn) + "Parse a chain of property/array accesses or function calls. +Includes parsing for E4X operators like `..' and `.@'. +If ALLOW-CALL-SYNTAX is nil, stops when we encounter a left-paren. +Returns an expression tree that includes PN, the parent node." + (let (tt + (continue t)) + (while continue + (setq tt (js2-get-token)) + (cond + ((or (= tt js2-DOT) (= tt js2-DOTDOT)) + (setq pn (js2-parse-property-access tt pn))) + ((= tt js2-DOTQUERY) + (setq pn (js2-parse-dot-query pn))) + ((= tt js2-LB) + (setq pn (js2-parse-element-get pn))) + ((= tt js2-LP) + (js2-unget-token) + (if allow-call-syntax + (setq pn (js2-parse-function-call pn)) + (setq continue nil))) + ((= tt js2-TEMPLATE_HEAD) + (setq pn (js2-parse-tagged-template pn (js2-parse-template-literal)))) + ((= tt js2-NO_SUBS_TEMPLATE) + (setq pn (js2-parse-tagged-template pn (make-js2-string-node :type tt)))) + (t + (js2-unget-token) + (setq continue nil))) + (if (>= js2-highlight-level 2) + (js2-parse-highlight-member-expr-node pn))) + pn)) + +(defun js2-parse-tagged-template (tag-node tpl-node) + "Parse tagged template expression." + (let* ((pos (js2-node-pos tag-node)) + (pn (make-js2-tagged-template-node :pos pos + :len (- (js2-current-token-end) pos) + :tag tag-node + :template tpl-node))) + (js2-node-add-children pn tag-node tpl-node) + pn)) + +(defun js2-parse-dot-query (pn) + "Parse a dot-query expression, e.g. foo.bar.(@name == 2) +Last token parsed must be `js2-DOTQUERY'." + (let ((pos (js2-node-pos pn)) + op-pos expr end) + (js2-must-have-xml) + (js2-set-requires-activation) + (setq op-pos (js2-current-token-beg) + expr (js2-parse-expr) + end (js2-node-end expr) + pn (make-js2-xml-dot-query-node :left pn + :pos pos + :op-pos op-pos + :right expr)) + (js2-node-add-children pn + (js2-xml-dot-query-node-left pn) + (js2-xml-dot-query-node-right pn)) + (if (js2-must-match js2-RP "msg.no.paren") + (setf (js2-xml-dot-query-node-rp pn) (js2-current-token-beg) + end (js2-current-token-end))) + (setf (js2-node-len pn) (- end pos)) + pn)) + +(defun js2-parse-element-get (pn) + "Parse an element-get expression, e.g. foo[bar]. +Last token parsed must be `js2-RB'." + (let ((lb (js2-current-token-beg)) + (pos (js2-node-pos pn)) + rb expr) + (setq expr (js2-parse-expr)) + (if (js2-must-match js2-RB "msg.no.bracket.index") + (setq rb (js2-current-token-beg))) + (setq pn (make-js2-elem-get-node :target pn + :pos pos + :element expr + :lb (js2-relpos lb pos) + :rb (js2-relpos rb pos) + :len (- (js2-current-token-end) pos))) + (js2-node-add-children pn + (js2-elem-get-node-target pn) + (js2-elem-get-node-element pn)) + pn)) + +(defun js2-highlight-function-call (token) + (when (eq (js2-token-type token) js2-NAME) + (js2-record-face 'js2-function-call token))) + +(defun js2-parse-function-call (pn) + (js2-highlight-function-call (js2-current-token)) + (js2-get-token) + (let (args + (pos (js2-node-pos pn))) + (setq pn (make-js2-call-node :pos pos + :target pn + :lp (- (js2-current-token-beg) pos))) + (js2-node-add-children pn (js2-call-node-target pn)) + ;; Add the arguments to pn, if any are supplied. + (setf args (nreverse (js2-parse-argument-list)) + (js2-call-node-rp pn) (- (js2-current-token-beg) pos) + (js2-call-node-args pn) args) + (apply #'js2-node-add-children pn args) + (setf (js2-node-len pn) (- js2-ts-cursor pos)) + pn)) + +(defun js2-parse-property-access (tt pn) + "Parse a property access, XML descendants access, or XML attr access." + (let ((member-type-flags 0) + (dot-pos (js2-current-token-beg)) + (dot-len (if (= tt js2-DOTDOT) 2 1)) + name + ref ; right side of . or .. operator + result) + (when (= tt js2-DOTDOT) + (js2-must-have-xml) + (setq member-type-flags js2-descendants-flag)) + (if (not js2-compiler-xml-available) + (progn + (js2-must-match-prop-name "msg.no.name.after.dot") + (setq name (js2-create-name-node t js2-GETPROP) + result (make-js2-prop-get-node :left pn + :pos (js2-current-token-beg) + :right name + :len (js2-current-token-len))) + (js2-node-add-children result pn name) + result) + ;; otherwise look for XML operators + (setf result (if (= tt js2-DOT) + (make-js2-prop-get-node) + (make-js2-infix-node :type js2-DOTDOT)) + (js2-node-pos result) (js2-node-pos pn) + (js2-infix-node-op-pos result) dot-pos + (js2-infix-node-left result) pn ; do this after setting position + tt (js2-get-prop-name-token)) + (cond + ;; handles: name, ns::name, ns::*, ns::[expr] + ((= tt js2-NAME) + (setq ref (js2-parse-property-name -1 nil member-type-flags))) + ;; handles: *, *::name, *::*, *::[expr] + ((= tt js2-MUL) + (setq ref (js2-parse-property-name nil "*" member-type-flags))) + ;; handles: '@attr', '@ns::attr', '@ns::*', '@ns::[expr]', etc. + ((= tt js2-XMLATTR) + (setq result (js2-parse-attribute-access))) + (t + (js2-report-error "msg.no.name.after.dot" nil dot-pos dot-len))) + (if ref + (setf (js2-node-len result) (- (js2-node-end ref) + (js2-node-pos result)) + (js2-infix-node-right result) ref)) + (if (js2-infix-node-p result) + (js2-node-add-children result + (js2-infix-node-left result) + (js2-infix-node-right result))) + result))) + +(defun js2-parse-attribute-access () + "Parse an E4X XML attribute expression. +This includes expressions of the forms: + + @attr @ns::attr @ns::* + @* @*::attr @*::* + @[expr] @*::[expr] @ns::[expr] + +Called if we peeked an `@' token." + (let ((tt (js2-get-prop-name-token)) + (at-pos (js2-current-token-beg))) + (cond + ;; handles: @name, @ns::name, @ns::*, @ns::[expr] + ((= tt js2-NAME) + (js2-parse-property-name at-pos nil 0)) + ;; handles: @*, @*::name, @*::*, @*::[expr] + ((= tt js2-MUL) + (js2-parse-property-name (js2-current-token-beg) "*" 0)) + ;; handles @[expr] + ((= tt js2-LB) + (js2-parse-xml-elem-ref at-pos)) + (t + (js2-report-error "msg.no.name.after.xmlAttr") + ;; Avoid cascaded errors that happen if we make an error node here. + (js2-parse-property-name (js2-current-token-beg) "" 0))))) + +(defun js2-parse-property-name (at-pos s member-type-flags) + "Check if :: follows name in which case it becomes qualified name. + +AT-POS is a natural number if we just read an `@' token, else nil. +S is the name or string that was matched: an identifier, `throw' or `*'. +MEMBER-TYPE-FLAGS is a bit set tracking whether we're a `.' or `..' child. + +Returns a `js2-xml-ref-node' if it's an attribute access, a child of a `..' +operator, or the name is followed by ::. For a plain name, returns a +`js2-name-node'. Returns a `js2-error-node' for malformed XML expressions." + (let ((pos (or at-pos (js2-current-token-beg))) + colon-pos + (name (js2-create-name-node t (js2-current-token-type) s)) + ns tt pn) + (catch 'return + (when (js2-match-token js2-COLONCOLON) + (setq ns name + colon-pos (js2-current-token-beg) + tt (js2-get-prop-name-token)) + (cond + ;; handles name::name + ((= tt js2-NAME) + (setq name (js2-create-name-node))) + ;; handles name::* + ((= tt js2-MUL) + (setq name (js2-create-name-node nil nil "*"))) + ;; handles name::[expr] + ((= tt js2-LB) + (throw 'return (js2-parse-xml-elem-ref at-pos ns colon-pos))) + (t + (js2-report-error "msg.no.name.after.coloncolon")))) + (if (and (null ns) (zerop member-type-flags)) + name + (prog1 + (setq pn + (make-js2-xml-prop-ref-node :pos pos + :len (- (js2-node-end name) pos) + :at-pos at-pos + :colon-pos colon-pos + :propname name)) + (js2-node-add-children pn name)))))) + +(defun js2-parse-xml-elem-ref (at-pos &optional namespace colon-pos) + "Parse the [expr] portion of an xml element reference. +For instance, @[expr], @*::[expr], or ns::[expr]." + (let* ((lb (js2-current-token-beg)) + (pos (or at-pos lb)) + rb + (expr (js2-parse-expr)) + (end (js2-node-end expr)) + pn) + (if (js2-must-match js2-RB "msg.no.bracket.index") + (setq rb (js2-current-token-beg) + end (js2-current-token-end))) + (prog1 + (setq pn + (make-js2-xml-elem-ref-node :pos pos + :len (- end pos) + :namespace namespace + :colon-pos colon-pos + :at-pos at-pos + :expr expr + :lb (js2-relpos lb pos) + :rb (js2-relpos rb pos))) + (js2-node-add-children pn namespace expr)))) + +(defun js2-parse-destruct-primary-expr () + (let ((js2-is-in-destructuring t)) + (js2-parse-primary-expr))) + +(defun js2-parse-primary-expr () + "Parse a literal (leaf) expression of some sort. +Includes complex literals such as functions, object-literals, +array-literals, array comprehensions and regular expressions." + (let (tt node) + (setq tt (js2-current-token-type)) + (cond + ((= tt js2-CLASS) + (js2-parse-class-expr)) + ((= tt js2-FUNCTION) + (js2-parse-function-expr)) + ((js2-match-async-function) + (js2-parse-function-expr t)) + ((= tt js2-LB) + (js2-parse-array-comp-or-literal)) + ((= tt js2-LC) + (js2-parse-object-literal)) + ((= tt js2-LET) + (js2-parse-let (js2-current-token-beg))) + ((= tt js2-LP) + (js2-parse-paren-expr-or-generator-comp)) + ((= tt js2-XMLATTR) + (js2-must-have-xml) + (js2-parse-attribute-access)) + ((= tt js2-NAME) + (js2-parse-name tt)) + ((= tt js2-NUMBER) + (setq node (make-js2-number-node)) + (when (and js2-in-use-strict-directive + (= (js2-number-node-num-base node) 8) + (js2-number-node-legacy-octal-p node)) + (js2-report-error "msg.no.octal.strict")) + node) + ((or (= tt js2-STRING) (= tt js2-NO_SUBS_TEMPLATE)) + (make-js2-string-node :type tt)) + ((= tt js2-TEMPLATE_HEAD) + (js2-parse-template-literal)) + ((or (= tt js2-DIV) (= tt js2-ASSIGN_DIV)) + ;; Got / or /= which in this context means a regexp literal + (let* ((px-pos (js2-current-token-beg)) + (flags (js2-read-regexp tt px-pos)) + (end (js2-current-token-end))) + (prog1 + (make-js2-regexp-node :pos px-pos + :len (- end px-pos) + :value (js2-current-token-string) + :flags flags) + (js2-set-face px-pos end 'font-lock-string-face 'record)))) + ((or (= tt js2-NULL) + (= tt js2-THIS) + (= tt js2-SUPER) + (= tt js2-FALSE) + (= tt js2-TRUE)) + (make-js2-keyword-node :type tt)) + ((= tt js2-TRIPLEDOT) + ;; Likewise, only valid in an arrow function with a rest param. + (if (and (js2-match-token js2-NAME) + (js2-match-token js2-RP) + (eq (js2-peek-token) js2-ARROW)) + (progn + (js2-unget-token) ; Put back the right paren. + ;; See the previous case. + (make-js2-keyword-node :type js2-NULL)) + (js2-report-error "msg.syntax") + (make-js2-error-node))) + ((= tt js2-RESERVED) + (js2-report-error "msg.reserved.id") + (make-js2-name-node)) + ((= tt js2-ERROR) + ;; the scanner or one of its subroutines reported the error. + (make-js2-error-node)) + ((= tt js2-EOF) + (let* ((px-pos (point-at-bol)) + (len (- js2-ts-cursor px-pos))) + (js2-report-error "msg.unexpected.eof" nil px-pos len)) + (make-js2-error-node :pos (1- js2-ts-cursor))) + (t + (js2-report-error "msg.syntax") + (make-js2-error-node))))) + +(defun js2-parse-template-literal () + (let ((beg (js2-current-token-beg)) + (kids (list (make-js2-string-node :type js2-TEMPLATE_HEAD))) + (tt js2-TEMPLATE_HEAD)) + (while (eq tt js2-TEMPLATE_HEAD) + (push (js2-parse-expr) kids) + (js2-must-match js2-RC "msg.syntax") + (setq tt (js2-get-token 'TEMPLATE_TAIL)) + (push (make-js2-string-node :type tt) kids)) + (setq kids (nreverse kids)) + (let ((tpl (make-js2-template-node :pos beg + :len (- (js2-current-token-end) beg) + :kids kids))) + (apply #'js2-node-add-children tpl kids) + tpl))) + +(defun js2-parse-name (_tt) + (let ((name (js2-current-token-string)) + node) + (setq node (if js2-compiler-xml-available + (js2-parse-property-name nil name 0) + (js2-create-name-node 'check-activation nil name))) + (if (and js2-highlight-external-variables + ;; FIXME: What's TRT for `js2-xml-ref-node'? + (js2-name-node-p node)) + (js2-record-name-node node)) + node)) + +(defun js2-parse-warn-trailing-comma (msg pos elems comma-pos) + (js2-add-strict-warning + msg nil + ;; back up from comma to beginning of line or array/objlit + (max (if elems + (js2-node-pos (car elems)) + pos) + (save-excursion + (goto-char comma-pos) + (back-to-indentation) + (point))) + comma-pos)) + +(defun js2-parse-array-comp-or-literal () + (let ((pos (js2-current-token-beg))) + (if (and (>= js2-language-version 200) + (js2-match-token js2-FOR)) + (js2-parse-array-comp pos) + (js2-parse-array-literal pos)))) + +(defun js2-parse-array-literal (pos) + (let ((after-lb-or-comma t) + after-comma tt elems pn was-rest + (continue t)) + (unless js2-is-in-destructuring + (js2-push-scope (make-js2-scope))) ; for the legacy array comp + (while continue + (setq tt (js2-get-token)) + (cond + ;; end of array + ((or (= tt js2-RB) + (= tt js2-EOF)) ; prevent infinite loop + (if (= tt js2-EOF) + (js2-report-error "msg.no.bracket.arg" nil pos)) + (when (and after-comma (< js2-language-version 170)) + (js2-parse-warn-trailing-comma "msg.array.trailing.comma" + pos (remove nil elems) after-comma)) + (setq continue nil + pn (make-js2-array-node :pos pos + :len (- js2-ts-cursor pos) + :elems (nreverse elems))) + (apply #'js2-node-add-children pn (js2-array-node-elems pn))) + ;; anything after rest element (...foo) + (was-rest + (js2-report-error "msg.param.after.rest")) + ;; comma + ((= tt js2-COMMA) + (setq after-comma (js2-current-token-end)) + (if (not after-lb-or-comma) + (setq after-lb-or-comma t) + (push nil elems))) + ;; array comp + ((and (>= js2-language-version 170) + (not js2-is-in-destructuring) + (= tt js2-FOR) ; check for array comprehension + (not after-lb-or-comma) ; "for" can't follow a comma + elems ; must have at least 1 element + (not (cdr elems))) ; but no 2nd element + (js2-unget-token) + (setf continue nil + pn (js2-parse-legacy-array-comp (car elems) pos))) + ;; another element + (t + (unless after-lb-or-comma + (js2-report-error "msg.no.bracket.arg")) + (if (and (= tt js2-TRIPLEDOT) + (>= js2-language-version 200)) + ;; rest/spread operator + (progn + (push (js2-make-unary nil tt 'js2-parse-assign-expr) + elems) + (if js2-is-in-destructuring + (setq was-rest t))) + (js2-unget-token) + (push (js2-parse-assign-expr) elems)) + (setq after-lb-or-comma nil + after-comma nil)))) + (unless js2-is-in-destructuring + (js2-pop-scope)) + pn)) + +(defun js2-parse-legacy-array-comp (expr pos) + "Parse a legacy array comprehension (JavaScript 1.7). +EXPR is the first expression after the opening left-bracket. +POS is the beginning of the LB token preceding EXPR. +We should have just parsed the `for' keyword before calling this function." + (let ((current-scope js2-current-scope) + loops first filter result) + (unwind-protect + (progn + (while (js2-match-token js2-FOR) + (let ((loop (make-js2-comp-loop-node))) + (js2-push-scope loop) + (push loop loops) + (js2-parse-comp-loop loop))) + ;; First loop takes expr scope's parent. + (setf (js2-scope-parent-scope (setq first (car (last loops)))) + (js2-scope-parent-scope current-scope)) + ;; Set expr scope's parent to the last loop. + (setf (js2-scope-parent-scope current-scope) (car loops)) + (if (/= (js2-get-token) js2-IF) + (js2-unget-token) + (setq filter (js2-parse-condition)))) + (dotimes (_ (1- (length loops))) + (js2-pop-scope))) + (js2-must-match js2-RB "msg.no.bracket.arg" pos) + (setq result (make-js2-comp-node :pos pos + :len (- js2-ts-cursor pos) + :result expr + :loops (nreverse loops) + :filters (and filter (list (car filter))) + :form 'LEGACY_ARRAY)) + ;; Set comp loop's parent to the last loop. + ;; TODO: Get rid of the bogus expr scope. + (setf (js2-scope-parent-scope result) first) + (apply #'js2-node-add-children result expr (car filter) + (js2-comp-node-loops result)) + result)) + +(defun js2-parse-array-comp (pos) + "Parse an ES6 array comprehension. +POS is the beginning of the LB token. +We should have just parsed the `for' keyword before calling this function." + (let ((pn (js2-parse-comprehension pos 'ARRAY))) + (js2-must-match js2-RB "msg.no.bracket.arg" pos) + pn)) + +(defun js2-parse-generator-comp (pos) + (let* ((js2-nesting-of-function (1+ js2-nesting-of-function)) + (js2-current-script-or-fn + (make-js2-function-node :generator-type 'COMPREHENSION)) + (pn (js2-parse-comprehension pos 'STAR_GENERATOR))) + (js2-must-match js2-RP "msg.no.paren" pos) + pn)) + +(defun js2-parse-comprehension (pos form) + (let (loops filters expr result last) + (unwind-protect + (progn + (js2-unget-token) + (while (js2-match-token js2-FOR) + (let ((loop (make-js2-comp-loop-node))) + (js2-push-scope loop) + (push loop loops) + (js2-parse-comp-loop loop))) + (while (js2-match-token js2-IF) + (push (car (js2-parse-condition)) filters)) + (setq expr (js2-parse-assign-expr)) + (setq last (car loops))) + (dolist (_ loops) + (js2-pop-scope))) + (setq result (make-js2-comp-node :pos pos + :len (- js2-ts-cursor pos) + :result expr + :loops (nreverse loops) + :filters (nreverse filters) + :form form)) + (apply #'js2-node-add-children result (js2-comp-node-loops result)) + (apply #'js2-node-add-children result expr (js2-comp-node-filters result)) + (setf (js2-scope-parent-scope result) last) + result)) + +(defun js2-parse-comp-loop (pn &optional only-of-p) + "Parse a `for [each] (foo [in|of] bar)' expression in an Array comprehension. +The current token should be the initial FOR. +If ONLY-OF-P is non-nil, only the `for (foo of bar)' form is allowed." + (let ((pos (js2-comp-loop-node-pos pn)) + tt iter obj foreach-p forof-p in-pos each-pos lp rp) + (when (and (not only-of-p) (js2-match-token js2-NAME)) + (if (string= (js2-current-token-string) "each") + (progn + (setq foreach-p t + each-pos (- (js2-current-token-beg) pos)) ; relative + (js2-record-face 'font-lock-keyword-face)) + (js2-report-error "msg.no.paren.for"))) + (if (js2-must-match js2-LP "msg.no.paren.for") + (setq lp (- (js2-current-token-beg) pos))) + (setq tt (js2-peek-token)) + (cond + ((or (= tt js2-LB) + (= tt js2-LC)) + (js2-get-token) + (setq iter (js2-parse-destruct-primary-expr)) + (js2-define-destruct-symbols iter js2-LET + 'font-lock-variable-name-face t)) + ((js2-match-token js2-NAME) + (setq iter (js2-create-name-node))) + (t + (js2-report-error "msg.bad.var"))) + ;; Define as a let since we want the scope of the variable to + ;; be restricted to the array comprehension + (if (js2-name-node-p iter) + (js2-define-symbol js2-LET (js2-name-node-name iter) pn t)) + (if (or (and (not only-of-p) (js2-match-token js2-IN)) + (and (>= js2-language-version 200) + (js2-match-contextual-kwd "of") + (setq forof-p t))) + (setq in-pos (- (js2-current-token-beg) pos)) + (js2-report-error "msg.in.after.for.name")) + (setq obj (js2-parse-expr)) + (if (js2-must-match js2-RP "msg.no.paren.for.ctrl") + (setq rp (- (js2-current-token-beg) pos))) + (setf (js2-node-pos pn) pos + (js2-node-len pn) (- js2-ts-cursor pos) + (js2-comp-loop-node-iterator pn) iter + (js2-comp-loop-node-object pn) obj + (js2-comp-loop-node-in-pos pn) in-pos + (js2-comp-loop-node-each-pos pn) each-pos + (js2-comp-loop-node-foreach-p pn) foreach-p + (js2-comp-loop-node-forof-p pn) forof-p + (js2-comp-loop-node-lp pn) lp + (js2-comp-loop-node-rp pn) rp) + (js2-node-add-children pn iter obj) + pn)) + +(defun js2-parse-class-stmt () + (let ((pos (js2-current-token-beg)) + (_ (js2-must-match-name "msg.unnamed.class.stmt")) + (name (js2-create-name-node t))) + (js2-set-face (js2-node-pos name) (js2-node-end name) + 'font-lock-function-name-face 'record) + (let ((node (js2-parse-class pos 'CLASS_STATEMENT name))) + (js2-record-imenu-functions node name) + (js2-define-symbol js2-FUNCTION + (js2-name-node-name name) + node) + node))) + +(defun js2-parse-class-expr () + (let ((pos (js2-current-token-beg)) + name) + (when (js2-match-token js2-NAME) + (setq name (js2-create-name-node t))) + (js2-parse-class pos 'CLASS_EXPRESSION name))) + +(defun js2-parse-class (pos form name) + ;; class X [extends ...] { + (let (pn elems extends) + (if (js2-match-token js2-EXTENDS) + (if (= (js2-peek-token) js2-LC) + (js2-report-error "msg.missing.extends") + ;; TODO(sdh): this should be left-hand-side-expr, not assign-expr + (setq extends (js2-parse-assign-expr)) + (if (not extends) + (js2-report-error "msg.bad.extends")))) + (js2-must-match js2-LC "msg.no.brace.class") + (setq elems (js2-parse-object-literal-elems t) + pn (make-js2-class-node :pos pos + :len (- js2-ts-cursor pos) + :form form + :name name + :extends extends + :elems elems)) + (apply #'js2-node-add-children + pn name extends (js2-class-node-elems pn)) + pn)) + +(defun js2-parse-object-literal () + (let* ((pos (js2-current-token-beg)) + (elems (js2-parse-object-literal-elems)) + (result (make-js2-object-node :pos pos + :len (- js2-ts-cursor pos) + :elems elems))) + (apply #'js2-node-add-children result (js2-object-node-elems result)) + result)) + +(defun js2-property-key-string (property-node) + "Return the key of PROPERTY-NODE (a `js2-object-prop-node' or +`js2-method-node') as a string, or nil if it can't be +represented as a string (e.g., the key is computed by an +expression)." + (cond + ((js2-unary-node-p property-node) nil) ;; {...foo} + (t + (let ((key (js2-infix-node-left property-node))) + (when (js2-computed-prop-name-node-p key) + (setq key (js2-computed-prop-name-node-expr key))) + (cond + ((js2-name-node-p key) + (js2-name-node-name key)) + ((js2-string-node-p key) + (js2-string-node-value key)) + ((js2-number-node-p key) + (js2-number-node-value key))))))) + +(defun js2-parse-object-literal-elems (&optional class-p) + (let ((pos (js2-current-token-beg)) + (static nil) + (continue t) + tt elems elem + elem-key-string previous-elem-key-string + after-comma previous-token) + (while continue + (setq tt (js2-get-prop-name-token) + static nil + elem nil + previous-token nil) + ;; Handle 'static' keyword only if we're in a class + (when (and class-p (= js2-NAME tt) + (string= "static" (js2-current-token-string))) + (js2-record-face 'font-lock-keyword-face) + (setq static t + tt (js2-get-prop-name-token))) + ;; Handle generator * before the property name for in-line functions + (when (and (>= js2-language-version 200) + (= js2-MUL tt)) + (setq previous-token (js2-current-token) + tt (js2-get-prop-name-token))) + ;; Handle getter, setter and async methods + (let ((prop (js2-current-token-string))) + (when (and (>= js2-language-version 200) + (= js2-NAME tt) + (member prop '("get" "set" "async")) + (member (js2-peek-token 'KEYWORD_IS_NAME) + (list js2-NAME js2-STRING js2-NUMBER js2-LB))) + (setq previous-token (js2-current-token) + tt (js2-get-prop-name-token)))) + (cond + ;; Rest/spread (...expr) + ((and (>= js2-language-version 200) + (not class-p) (not static) (not previous-token) + (= js2-TRIPLEDOT tt)) + (setq after-comma nil + elem (js2-make-unary nil js2-TRIPLEDOT 'js2-parse-assign-expr))) + ;; Found a key/value property (of any sort) + ((member tt (list js2-NAME js2-STRING js2-NUMBER js2-LB)) + (setq after-comma nil + elem (js2-parse-named-prop tt previous-token class-p)) + (if (and (null elem) + (not js2-recover-from-parse-errors)) + (setq continue nil))) + ;; Break out of loop, and handle trailing commas. + ((or (= tt js2-RC) + (= tt js2-EOF)) + (js2-unget-token) + (setq continue nil) + (if after-comma + (js2-parse-warn-trailing-comma "msg.extra.trailing.comma" + pos elems after-comma))) + ;; Skip semicolons in a class body + ((and class-p + (= tt js2-SEMI)) + nil) + (t + (js2-report-error "msg.bad.prop") + (unless js2-recover-from-parse-errors + (setq continue nil)))) ; end switch + ;; Handle static for classes' codegen. + (if static + (if elem (js2-node-set-prop elem 'STATIC t) + (js2-report-error "msg.unexpected.static"))) + ;; Handle commas, depending on class-p. + (let ((tok (js2-get-prop-name-token))) + (if (eq tok js2-COMMA) + (if class-p + (js2-report-error "msg.class.unexpected.comma") + (setq after-comma (js2-current-token-end))) + (js2-unget-token) + (unless class-p (setq continue nil)))) + (when elem + (when (and js2-in-use-strict-directive + (setq elem-key-string (js2-property-key-string elem)) + (cl-some + (lambda (previous-elem) + (and (setq previous-elem-key-string + (js2-property-key-string previous-elem)) + ;; Check if the property is a duplicate. + (string= previous-elem-key-string elem-key-string) + ;; But make an exception for getter / setter pairs. + (not (and (js2-method-node-p elem) + (js2-method-node-p previous-elem) + (let ((type (js2-node-get-prop (js2-method-node-right elem) 'METHOD_TYPE)) + (previous-type (js2-node-get-prop (js2-method-node-right previous-elem) 'METHOD_TYPE))) + (and (member type '(GET SET)) + (member previous-type '(GET SET)) + (not (eq type previous-type)))))))) + elems)) + (js2-report-error "msg.dup.obj.lit.prop.strict" + elem-key-string + (js2-node-abs-pos (js2-infix-node-left elem)) + (js2-node-len (js2-infix-node-left elem)))) + ;; Append any parsed element. + (push elem elems))) ; end loop + (js2-must-match js2-RC "msg.no.brace.prop") + (nreverse elems))) + +(defun js2-parse-named-prop (tt previous-token &optional class-p) + "Parse a name, string, or getter/setter object property. +When `js2-is-in-destructuring' is t, forms like {a, b, c} will be permitted." + (let ((key (js2-parse-prop-name tt)) + (prop (and previous-token (js2-token-string previous-token))) + (property-type (when previous-token + (if (= (js2-token-type previous-token) js2-MUL) + "*" + (js2-token-string previous-token)))) + pos) + (when (member prop '("get" "set" "async")) + (setq pos (js2-token-beg previous-token)) + (js2-set-face (js2-token-beg previous-token) + (js2-token-end previous-token) + 'font-lock-keyword-face 'record)) ; get/set/async + (cond + ;; method definition: {f() {...}} + ((and (= (js2-peek-token) js2-LP) + (>= js2-language-version 200)) + (when (or (js2-name-node-p key) (js2-string-node-p key)) + ;; highlight function name properties + (js2-record-face 'font-lock-function-name-face)) + (js2-parse-method-prop pos key property-type)) + ;; class field or binding element with initializer + ((and (= (js2-peek-token) js2-ASSIGN) + (>= js2-language-version 200)) + (if (not (or class-p + js2-is-in-destructuring)) + (js2-report-error "msg.init.no.destruct")) + (js2-parse-initialized-binding key)) + ;; regular prop + (t + (let ((beg (js2-current-token-beg)) + (end (js2-current-token-end)) + (expr (js2-parse-plain-property key class-p))) + (when (and (= tt js2-NAME) + (not js2-is-in-destructuring) + js2-highlight-external-variables + (js2-node-get-prop expr 'SHORTHAND)) + (js2-record-name-node key)) + (js2-set-face beg end + (if (js2-function-node-p + (js2-object-prop-node-right expr)) + 'font-lock-function-name-face + 'js2-object-property) + 'record) + expr))))) + +(defun js2-parse-initialized-binding (name) + "Parse a `SingleNameBinding' with initializer. + +`name' is the `BindingIdentifier'." + (when (js2-match-token js2-ASSIGN) + (js2-make-binary js2-ASSIGN name 'js2-parse-assign-expr t))) + +(defun js2-parse-prop-name (tt) + (cond + ;; Literal string keys: {'foo': 'bar'} + ((= tt js2-STRING) + (make-js2-string-node)) + ;; Handle computed keys: {[Symbol.iterator]: ...}, *[1+2]() {...}}, + ;; {[foo + bar]() { ... }}, {[get ['x' + 1]() {...}} + ((and (= tt js2-LB) + (>= js2-language-version 200)) + (make-js2-computed-prop-name-node + :expr (prog1 (js2-parse-assign-expr) + (js2-must-match js2-RB "msg.missing.computed.rb")))) + ;; Numeric keys: {12: 'foo'}, {10.7: 'bar'} + ((= tt js2-NUMBER) + (make-js2-number-node)) + ;; Unquoted names: {foo: 12} + ((= tt js2-NAME) + (js2-create-name-node)) + ;; Anything else is an error + (t (js2-report-error "msg.bad.prop")))) + +(defun js2-parse-plain-property (prop &optional class-p) + "Parse a non-getter/setter property in an object literal. +PROP is the node representing the property: a number, name, +string or expression." + (let* (tt + (pos (js2-node-pos prop)) + colon expr result) + (cond + ;; Abbreviated property, as in {foo, bar} or class {a; b} + ((and (>= js2-language-version 200) + (if class-p + (and (setq tt (js2-peek-token-or-eol)) + (member tt (list js2-EOL js2-RC js2-SEMI))) + (and (setq tt (js2-peek-token)) + (member tt (list js2-COMMA js2-RC)) + (js2-name-node-p prop)))) + (setq result (make-js2-object-prop-node + :pos pos + :len (js2-node-len prop) + :left prop + :right prop + :op-pos (- (js2-current-token-beg) pos))) + (js2-node-add-children result prop) + (js2-node-set-prop result 'SHORTHAND t) + result) + ;; Normal property + (t + (setq tt (js2-get-token)) + (if (= tt js2-COLON) + (setq colon (- (js2-current-token-beg) pos) + expr (js2-parse-assign-expr)) + (js2-report-error "msg.no.colon.prop") + (setq expr (make-js2-error-node))) + (setq result (make-js2-object-prop-node + :pos pos + ;; don't include last consumed token in length + :len (- (+ (js2-node-pos expr) + (js2-node-len expr)) + pos) + :left prop + :right expr + :op-pos colon)) + (js2-node-add-children result prop expr) + result)))) + +(defun js2-parse-method-prop (pos prop type-string) + "Parse method property in an object literal or a class body. +JavaScript syntax is: + + { foo(...) {...}, get foo() {...}, set foo(x) {...}, *foo(...) {...}, + async foo(...) {...} } + +and expression closure style is also supported + + { get foo() x, set foo(x) _x = x } + +POS is the start position of the `get' or `set' keyword, if any. +PROP is the `js2-name-node' representing the property name. +TYPE-STRING is a string `get', `set', `*', or nil, indicating a found keyword." + (let* ((type (or (cdr (assoc type-string '(("get" . GET) + ("set" . SET) + ("async" . ASYNC)))) + 'FUNCTION)) + result end + (pos (or pos (js2-current-token-beg))) + (_ (js2-must-match js2-LP "msg.no.paren.parms")) + (fn (js2-parse-function 'FUNCTION_EXPRESSION pos + (string= type-string "*") + (eq type 'ASYNC) + nil))) + (js2-node-set-prop fn 'METHOD_TYPE type) ; for codegen + (unless pos (setq pos (js2-node-pos prop))) + (setq end (js2-node-end fn) + result (make-js2-method-node :pos pos + :len (- end pos) + :left prop + :right fn)) + (js2-node-add-children result prop fn) + result)) + +(defun js2-create-name-node (&optional check-activation-p token string) + "Create a name node using the current token and, optionally, STRING. +And, if CHECK-ACTIVATION-P is non-nil, use the value of TOKEN." + (let* ((beg (js2-current-token-beg)) + (tt (js2-current-token-type)) + (s (or string + (if (= js2-NAME tt) + (js2-current-token-string) + (js2-tt-name tt)))) + name) + (setq name (make-js2-name-node :pos beg + :name s + :len (length s))) + (if check-activation-p + (js2-check-activation-name s (or token js2-NAME))) + name)) + +;;; Use AST to extract semantic information + +(defun js2-get-element-index-from-array-node (elem array-node &optional hardcoded-array-index) + "Get index of ELEM from ARRAY-NODE or 0 and return it as string." + (let ((idx 0) elems (rlt hardcoded-array-index)) + (setq elems (js2-array-node-elems array-node)) + (if (and elem (not hardcoded-array-index)) + (setq rlt (catch 'nth-elt + (dolist (x elems) + ;; We know the ELEM does belong to ARRAY-NODE, + (if (eq elem x) (throw 'nth-elt idx)) + (setq idx (1+ idx))) + 0))) + (format "[%s]" rlt))) + +(defun js2-print-json-path (&optional hardcoded-array-index) + "Print the path to the JSON value under point, and save it in the kill ring. +If HARDCODED-ARRAY-INDEX provided, array index in JSON path is replaced with it." + (interactive "P") + (js2-reparse) + (let (previous-node current-node + key-name + rlt) + + ;; The `js2-node-at-point' starts scanning from AST root node. + ;; So there is no way to optimize it. + (setq current-node (js2-node-at-point)) + + (while (not (js2-ast-root-p current-node)) + (cond + ;; JSON property node + ((js2-object-prop-node-p current-node) + (setq key-name (js2-prop-node-name (js2-object-prop-node-left current-node))) + (if rlt (setq rlt (concat "." key-name rlt)) + (setq rlt (concat "." key-name)))) + + ;; Array node + ((or (js2-array-node-p current-node)) + (setq rlt (concat (js2-get-element-index-from-array-node previous-node + current-node + hardcoded-array-index) + rlt))) + + ;; Other nodes are ignored + (t)) + + ;; current node is archived + (setq previous-node current-node) + ;; Get parent node and continue the loop + (setq current-node (js2-node-parent current-node))) + + (cond + (rlt + ;; Clean the final result + (setq rlt (replace-regexp-in-string "^\\." "" rlt)) + (kill-new rlt) + (message "%s => kill-ring" rlt)) + (t + (message "No JSON path found!"))) + + rlt)) + +;;; Indentation support (bouncing) + +;; In recent-enough Emacs, we reuse the indentation code from +;; `js-mode'. To continue support for the older versions, some code +;; that was here previously was moved to `js2-old-indent.el'. + +;; Whichever indenter is used, it's often "wrong", however, and needs +;; to be overridden. The right long-term solution is probably to +;; emulate (or integrate with) cc-engine, but it's a nontrivial amount +;; of coding. Even when a parse tree from `js2-parse' is present, +;; which is not true at the moment the user is typing, computing +;; indentation is still thousands of lines of code to handle every +;; possible syntactic edge case. + +;; In the meantime, the compromise solution is that we offer a "bounce +;; indenter", configured with `js2-bounce-indent-p', which cycles the +;; current line indent among various likely guess points. This approach +;; is far from perfect, but should at least make it slightly easier to +;; move the line towards its desired indentation when manually +;; overriding Karl's heuristic nesting guesser. + +(defun js2-backward-sws () + "Move backward through whitespace and comments." + (interactive) + (while (forward-comment -1))) + +(defun js2-forward-sws () + "Move forward through whitespace and comments." + (interactive) + (while (forward-comment 1))) + +(defun js2-arglist-close () + "Return non-nil if we're on a line beginning with a close-paren/brace." + (save-excursion + (goto-char (point-at-bol)) + (js2-forward-sws) + (looking-at "[])}]"))) + +(defun js2-indent-looks-like-label-p () + (goto-char (point-at-bol)) + (js2-forward-sws) + (looking-at (concat js2-mode-identifier-re ":"))) + +(defun js2-indent-in-objlit-p (parse-status) + "Return non-nil if this looks like an object-literal entry." + (let ((start (nth 1 parse-status))) + (and + start + (save-excursion + (and (zerop (forward-line -1)) + (not (< (point) start)) ; crossed a {} boundary + (js2-indent-looks-like-label-p))) + (save-excursion + (js2-indent-looks-like-label-p))))) + +;; If prev line looks like foobar({ then we're passing an object +;; literal to a function call, and people pretty much always want to +;; de-dent back to the previous line, so move the 'basic-offset' +;; position to the front. +(defun js2-indent-objlit-arg-p (parse-status) + (save-excursion + (back-to-indentation) + (js2-backward-sws) + (and (eq (1- (point)) (nth 1 parse-status)) + (eq (char-before) ?{) + (progn + (forward-char -1) + (skip-chars-backward " \t") + (eq (char-before) ?\())))) + +(defun js2-indent-case-block-p () + (save-excursion + (back-to-indentation) + (js2-backward-sws) + (goto-char (point-at-bol)) + (skip-chars-forward " \t") + (looking-at "case\\s-.+:"))) + +(defun js2-bounce-indent (normal-col parse-status &optional backward) + "Cycle among alternate computed indentation positions. +PARSE-STATUS is the result of `parse-partial-sexp' from the beginning +of the buffer to the current point. NORMAL-COL is the indentation +column computed by the heuristic guesser based on current paren, +bracket, brace and statement nesting. If BACKWARDS, cycle positions +in reverse." + (let ((cur-indent (current-indentation)) + (old-buffer-undo-list buffer-undo-list) + ;; Emacs 21 only has `count-lines', not `line-number-at-pos' + (current-line (save-excursion + (forward-line 0) ; move to bol + (1+ (count-lines (point-min) (point))))) + positions pos main-pos anchor arglist-cont same-indent + basic-offset computed-pos) + ;; temporarily don't record undo info, if user requested this + (when js2-mode-indent-inhibit-undo + (setq buffer-undo-list t)) + (unwind-protect + (progn + ;; First likely point: indent from beginning of previous code line + (push (setq basic-offset + (+ (save-excursion + (back-to-indentation) + (js2-backward-sws) + (back-to-indentation) + (current-column)) + js2-basic-offset)) + positions) + + ;; (First + epsilon) likely point: indent 2x from beginning of + ;; previous code line. Google does it this way. + (push (setq basic-offset + (+ (save-excursion + (back-to-indentation) + (js2-backward-sws) + (back-to-indentation) + (current-column)) + (* 2 js2-basic-offset))) + positions) + + ;; Second likely point: indent from assign-expr RHS. This + ;; is just a crude guess based on finding " = " on the previous + ;; line containing actual code. + (setq pos (save-excursion + (forward-line -1) + (goto-char (point-at-bol)) + (when (re-search-forward "\\s-+\\(=\\)\\s-+" + (point-at-eol) t) + (goto-char (match-end 1)) + (skip-chars-forward " \t\r\n") + (current-column)))) + (when pos + (cl-incf pos js2-basic-offset) + (push pos positions)) + + ;; Third likely point: same indent as previous line of code. + ;; Make it the first likely point if we're not on an + ;; arglist-close line and previous line ends in a comma, or + ;; both this line and prev line look like object-literal + ;; elements. + (setq pos (save-excursion + (goto-char (point-at-bol)) + (js2-backward-sws) + (back-to-indentation) + (prog1 + (current-column) + ;; while we're here, look for trailing comma + (if (save-excursion + (goto-char (point-at-eol)) + (js2-backward-sws) + (eq (char-before) ?,)) + (setq arglist-cont (1- (point))))))) + (when pos + (if (and (or arglist-cont + (js2-indent-in-objlit-p parse-status)) + (not (js2-arglist-close))) + (setq same-indent pos)) + (push pos positions)) + + ;; Fourth likely point: first preceding code with less indentation. + ;; than the immediately preceding code line. + (setq pos (save-excursion + (back-to-indentation) + (js2-backward-sws) + (back-to-indentation) + (setq anchor (current-column)) + (while (and (zerop (forward-line -1)) + (>= (progn + (back-to-indentation) + (current-column)) + anchor))) + (setq pos (current-column)))) + (push pos positions) + + ;; nesting-heuristic position, main by default + (push (setq main-pos normal-col) positions) + + ;; delete duplicates and sort positions list + (setq positions (sort (delete-dups positions) '<)) + + ;; comma-list continuation lines: prev line indent takes precedence + (if same-indent + (setq main-pos same-indent)) + + ;; common special cases where we want to indent in from previous line + (if (or (js2-indent-case-block-p) + (js2-indent-objlit-arg-p parse-status)) + (setq main-pos basic-offset)) + + ;; if bouncing backward, reverse positions list + (if backward + (setq positions (reverse positions))) + + ;; record whether we're already sitting on one of the alternatives + (setq pos (member cur-indent positions)) + + (cond + ;; case 0: we're one one of the alternatives and this is the + ;; first time they've pressed TAB on this line (best-guess). + ((and js2-mode-indent-ignore-first-tab + pos + ;; first time pressing TAB on this line? + (not (eq js2-mode-last-indented-line current-line))) + ;; do nothing + (setq computed-pos nil)) + ;; case 1: only one computed position => use it + ((null (cdr positions)) + (setq computed-pos 0)) + ;; case 2: not on any of the computed spots => use main spot + ((not pos) + (setq computed-pos (js2-position main-pos positions))) + ;; case 3: on last position: cycle to first position + ((null (cdr pos)) + (setq computed-pos 0)) + ;; case 4: on intermediate position: cycle to next position + (t + (setq computed-pos (js2-position (cl-second pos) positions)))) + + ;; see if any hooks want to indent; otherwise we do it + (cl-loop with result = nil + for hook in js2-indent-hook + while (null result) + do + (setq result (funcall hook positions computed-pos)) + finally do + (unless (or result (null computed-pos)) + (indent-line-to (nth computed-pos positions))))) + + ;; finally + (if js2-mode-indent-inhibit-undo + (setq buffer-undo-list old-buffer-undo-list)) + ;; see commentary for `js2-mode-last-indented-line' + (setq js2-mode-last-indented-line current-line)))) + +(defun js2-1-line-comment-continuation-p () + "Return t if we're in a 1-line comment continuation. +If so, we don't ever want to use bounce-indent." + (save-excursion + (and (progn + (forward-line 0) + (looking-at "\\s-*//")) + (progn + (forward-line -1) + (forward-line 0) + (when (looking-at "\\s-*$") + (js2-backward-sws) + (forward-line 0)) + (looking-at "\\s-*//"))))) + +(defun js2-indent-bounce (&optional backward) + "Indent the current line, bouncing between several positions." + (interactive) + (let (parse-status offset indent-col + ;; Don't whine about errors/warnings when we're indenting. + ;; This has to be set before calling parse-partial-sexp below. + (inhibit-point-motion-hooks t)) + (setq parse-status (save-excursion + (syntax-ppss (point-at-bol))) + offset (- (point) (save-excursion + (back-to-indentation) + (point)))) + ;; Don't touch multiline strings. + (unless (nth 3 parse-status) + (setq indent-col (js2-proper-indentation parse-status)) + (cond + ;; It doesn't work well on first line of buffer. + ((and (not (nth 4 parse-status)) + (not (js2-same-line (point-min))) + (not (js2-1-line-comment-continuation-p))) + (js2-bounce-indent indent-col parse-status backward)) + ;; just indent to the guesser's likely spot + (t (indent-line-to indent-col))) + (when (cl-plusp offset) + (forward-char offset))))) + +(defun js2-indent-bounce-backward () + "Indent the current line, bouncing between positions in reverse." + (interactive) + (js2-indent-bounce t)) + +(defun js2-indent-region (start end) + "Indent the region, but don't use bounce indenting." + (let ((js2-bounce-indent-p nil) + (indent-region-function nil) + (after-change-functions (remq 'js2-mode-edit + after-change-functions))) + (indent-region start end nil) ; nil for byte-compiler + (js2-mode-edit start end (- end start)))) + +(defvar js2-minor-mode-map + (let ((map (make-sparse-keymap))) + (define-key map (kbd "C-c C-`") #'js2-next-error) + map) + "Keymap used when `js2-minor-mode' is active.") + +;;;###autoload +(define-minor-mode js2-minor-mode + "Minor mode for running js2 as a background linter. +This allows you to use a different major mode for JavaScript editing, +such as `js-mode', while retaining the asynchronous error/warning +highlighting features of `js2-mode'." + :group 'js2-mode + :lighter " js-lint" + (if (derived-mode-p 'js2-mode) + (setq js2-minor-mode nil) + (if js2-minor-mode + (js2-minor-mode-enter) + (js2-minor-mode-exit)))) + +(defun js2-minor-mode-enter () + "Initialization for `js2-minor-mode'." + (set (make-local-variable 'max-lisp-eval-depth) + (max max-lisp-eval-depth 3000)) + (setq next-error-function #'js2-next-error) + ;; Experiment: make reparse-delay longer for longer files. + (if (cl-plusp js2-dynamic-idle-timer-adjust) + (setq js2-idle-timer-delay + (* js2-idle-timer-delay + (/ (point-max) js2-dynamic-idle-timer-adjust)))) + (setq js2-mode-buffer-dirty-p t + js2-mode-parsing nil) + (set (make-local-variable 'js2-highlight-level) 0) ; no syntax highlighting + (add-hook 'after-change-functions #'js2-minor-mode-edit nil t) + (add-hook 'change-major-mode-hook #'js2-minor-mode-exit nil t) + (when js2-include-jslint-globals + (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals nil t)) + (when js2-include-jslint-declaration-externs + (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs nil t)) + (run-hooks 'js2-init-hook) + (js2-reparse)) + +(defun js2-minor-mode-exit () + "Turn off `js2-minor-mode'." + (setq next-error-function nil) + (remove-hook 'after-change-functions #'js2-mode-edit t) + (remove-hook 'change-major-mode-hook #'js2-minor-mode-exit t) + (when js2-mode-node-overlay + (delete-overlay js2-mode-node-overlay) + (setq js2-mode-node-overlay nil)) + (js2-remove-overlays) + (remove-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals t) + (remove-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs t) + (setq js2-mode-ast nil)) + +(defvar js2-source-buffer nil "Linked source buffer for diagnostics view") +(make-variable-buffer-local 'js2-source-buffer) + +(cl-defun js2-display-error-list () + "Display a navigable buffer listing parse errors/warnings." + (interactive) + (unless (js2-have-errors-p) + (message "No errors") + (cl-return-from js2-display-error-list)) + (cl-labels ((annotate-list + (lst type) + "Add diagnostic TYPE and line number to errs list" + (mapcar (lambda (err) + (list err type (line-number-at-pos (nth 1 err)))) + lst))) + (let* ((srcbuf (current-buffer)) + (errbuf (get-buffer-create "*js-lint*")) + (errors (annotate-list + (when js2-mode-ast (js2-ast-root-errors js2-mode-ast)) + 'js2-error)) ; must be a valid face name + (warnings (annotate-list + (when js2-mode-ast (js2-ast-root-warnings js2-mode-ast)) + 'js2-warning)) ; must be a valid face name + (all-errs (sort (append errors warnings) + (lambda (e1 e2) (< (cl-cadar e1) (cl-cadar e2)))))) + (with-current-buffer errbuf + (let ((inhibit-read-only t)) + (erase-buffer) + (dolist (err all-errs) + (cl-destructuring-bind ((msg-key beg _end &rest) type line) err + (insert-text-button + (format "line %d: %s" line (js2-get-msg msg-key)) + 'face type + 'follow-link "\C-m" + 'action 'js2-error-buffer-jump + 'js2-msg (js2-get-msg msg-key) + 'js2-pos beg) + (insert "\n")))) + (js2-error-buffer-mode) + (setq js2-source-buffer srcbuf) + (pop-to-buffer errbuf) + (goto-char (point-min)) + (unless (eobp) + (js2-error-buffer-view)))))) + +(defvar js2-error-buffer-mode-map + (let ((map (make-sparse-keymap))) + (define-key map "n" #'js2-error-buffer-next) + (define-key map "p" #'js2-error-buffer-prev) + (define-key map (kbd "RET") #'js2-error-buffer-jump) + (define-key map "o" #'js2-error-buffer-view) + (define-key map "q" #'js2-error-buffer-quit) + map) + "Keymap used for js2 diagnostics buffers.") + +(define-derived-mode js2-error-buffer-mode special-mode "JS Lint Diagnostics" + "Major mode for js2 diagnostics buffers. +Selecting an error will jump it to the corresponding source-buffer error. +\\{js2-error-buffer-mode-map}" + (setq truncate-lines t) + (set-buffer-modified-p nil) + (setq buffer-read-only t)) + +(defun js2-error-buffer-next () + "Move to next error and view it." + (interactive) + (when (zerop (forward-line 1)) + (js2-error-buffer-view))) + +(defun js2-error-buffer-prev () + "Move to previous error and view it." + (interactive) + (when (zerop (forward-line -1)) + (js2-error-buffer-view))) + +(defun js2-error-buffer-quit () + "Kill the current buffer." + (interactive) + (kill-buffer)) + +(defun js2-error-buffer-jump (&rest ignored) + "Jump cursor to current error in source buffer." + (interactive) + (when (js2-error-buffer-view) + (pop-to-buffer js2-source-buffer))) + +(defun js2-error-buffer-view () + "Scroll source buffer to show error at current line." + (interactive) + (cond + ((not (derived-mode-p 'js2-error-buffer-mode)) + (message "Not in a js2 errors buffer")) + ((not (buffer-live-p js2-source-buffer)) + (message "Source buffer has been killed")) + ((not (wholenump (get-text-property (point) 'js2-pos))) + (message "There does not seem to be an error here")) + (t + (let ((pos (get-text-property (point) 'js2-pos)) + (msg (get-text-property (point) 'js2-msg))) + (save-selected-window + (pop-to-buffer js2-source-buffer) + (goto-char pos) + (message msg)))))) + +;;;###autoload +(define-derived-mode js2-mode js-mode "Javascript-IDE" + "Major mode for editing JavaScript code." + (set (make-local-variable 'max-lisp-eval-depth) + (max max-lisp-eval-depth 3000)) + (set (make-local-variable 'indent-line-function) #'js2-indent-line) + (set (make-local-variable 'indent-region-function) #'js2-indent-region) + (set (make-local-variable 'syntax-propertize-function) nil) + (set (make-local-variable 'comment-line-break-function) #'js2-line-break) + (set (make-local-variable 'beginning-of-defun-function) #'js2-beginning-of-defun) + (set (make-local-variable 'end-of-defun-function) #'js2-end-of-defun) + ;; We un-confuse `parse-partial-sexp' by setting syntax-table properties + ;; for characters inside regexp literals. + (set (make-local-variable 'parse-sexp-lookup-properties) t) + ;; this is necessary to make `show-paren-function' work properly + (set (make-local-variable 'parse-sexp-ignore-comments) t) + ;; needed for M-x rgrep, among other things + (put 'js2-mode 'find-tag-default-function #'js2-mode-find-tag) + + (setq font-lock-defaults '(nil t)) + + ;; Experiment: make reparse-delay longer for longer files. + (when (cl-plusp js2-dynamic-idle-timer-adjust) + (setq js2-idle-timer-delay + (* js2-idle-timer-delay + (/ (point-max) js2-dynamic-idle-timer-adjust)))) + + (add-hook 'change-major-mode-hook #'js2-mode-exit nil t) + (add-hook 'after-change-functions #'js2-mode-edit nil t) + (setq imenu-create-index-function #'js2-mode-create-imenu-index) + (setq next-error-function #'js2-next-error) + (imenu-add-to-menubar (concat "IM-" mode-name)) + (add-to-invisibility-spec '(js2-outline . t)) + (set (make-local-variable 'line-move-ignore-invisible) t) + (set (make-local-variable 'forward-sexp-function) #'js2-mode-forward-sexp) + (when (fboundp 'cursor-sensor-mode) (cursor-sensor-mode 1)) + + (setq js2-mode-functions-hidden nil + js2-mode-comments-hidden nil + js2-mode-buffer-dirty-p t + js2-mode-parsing nil) + + (when js2-include-jslint-globals + (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals nil t)) + (when js2-include-jslint-declaration-externs + (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs nil t)) + + (run-hooks 'js2-init-hook) + + (let ((js2-idle-timer-delay 0)) + ;; Schedule parsing for after when the mode hooks run. + (js2-mode-reset-timer))) + +;; We may eventually want js2-jsx-mode to derive from js-jsx-mode, but that'd be +;; a bit more complicated and it doesn't net us much yet. +;;;###autoload +(define-derived-mode js2-jsx-mode js2-mode "JSX-IDE" + "Major mode for editing JSX code. + +To customize the indentation for this mode, set the SGML offset +variables (`sgml-basic-offset' et al) locally, like so: + + (defun set-jsx-indentation () + (setq-local sgml-basic-offset js2-basic-offset)) + (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation)" + (set (make-local-variable 'indent-line-function) #'js2-jsx-indent-line)) + +(defun js2-mode-exit () + "Exit `js2-mode' and clean up." + (interactive) + (when js2-mode-node-overlay + (delete-overlay js2-mode-node-overlay) + (setq js2-mode-node-overlay nil)) + (js2-remove-overlays) + (setq js2-mode-ast nil) + (remove-hook 'change-major-mode-hook #'js2-mode-exit t) + (remove-from-invisibility-spec '(js2-outline . t)) + (js2-mode-show-all) + (with-silent-modifications + (js2-clear-face (point-min) (point-max)))) + +(defun js2-mode-reset-timer () + "Cancel any existing parse timer and schedule a new one." + (if js2-mode-parse-timer + (cancel-timer js2-mode-parse-timer)) + (setq js2-mode-parsing nil) + (let ((timer (timer-create))) + (setq js2-mode-parse-timer timer) + (timer-set-function timer 'js2-mode-idle-reparse (list (current-buffer))) + (timer-set-idle-time timer js2-idle-timer-delay) + ;; http://debbugs.gnu.org/cgi/bugreport.cgi?bug=12326 + (timer-activate-when-idle timer nil))) + +(defun js2-mode-idle-reparse (buffer) + "Run `js2-reparse' if BUFFER is the current buffer, or schedule +it to be reparsed when the buffer is selected." + (cond ((eq buffer (current-buffer)) + (js2-reparse)) + ((buffer-live-p buffer) + ;; reparse when the buffer is selected again + (with-current-buffer buffer + (add-hook 'window-configuration-change-hook + #'js2-mode-idle-reparse-inner + nil t))))) + +(defun js2-mode-idle-reparse-inner () + (remove-hook 'window-configuration-change-hook + #'js2-mode-idle-reparse-inner + t) + (js2-reparse)) + +(defun js2-mode-edit (_beg _end _len) + "Schedule a new parse after buffer is edited. +Buffer edit spans from BEG to END and is of length LEN." + (setq js2-mode-buffer-dirty-p t) + (js2-mode-hide-overlay) + (js2-mode-reset-timer)) + +(defun js2-minor-mode-edit (_beg _end _len) + "Callback for buffer edits in `js2-mode'. +Schedules a new parse after buffer is edited. +Buffer edit spans from BEG to END and is of length LEN." + (setq js2-mode-buffer-dirty-p t) + (js2-mode-hide-overlay) + (js2-mode-reset-timer)) + +(defun js2-reparse (&optional force) + "Re-parse current buffer after user finishes some data entry. +If we get any user input while parsing, including cursor motion, +we discard the parse and reschedule it. If FORCE is nil, then the +buffer will only rebuild its `js2-mode-ast' if the buffer is dirty." + (let (time + interrupted-p + (js2-compiler-strict-mode js2-mode-show-strict-warnings)) + (unless js2-mode-parsing + (setq js2-mode-parsing t) + (unwind-protect + (when (or js2-mode-buffer-dirty-p force) + (js2-remove-overlays) + (setq js2-mode-buffer-dirty-p nil + js2-mode-fontifications nil + js2-mode-deferred-properties nil) + (if js2-mode-verbose-parse-p + (message "parsing...")) + (setq time + (js2-time + (setq interrupted-p + (catch 'interrupted + (js2-parse) + (with-silent-modifications + ;; if parsing is interrupted, comments and regex + ;; literals stay ignored by `parse-partial-sexp' + (remove-text-properties (point-min) (point-max) + '(syntax-table)) + (js2-mode-apply-deferred-properties) + (js2-mode-remove-suppressed-warnings) + (js2-mode-show-warnings) + (js2-mode-show-errors) + (if (>= js2-highlight-level 1) + (js2-highlight-jsdoc js2-mode-ast))) + nil)))) + (if interrupted-p + (progn + ;; unfinished parse => try again + (setq js2-mode-buffer-dirty-p t) + (js2-mode-reset-timer)) + (if js2-mode-verbose-parse-p + (message "Parse time: %s" time)))) + (setq js2-mode-parsing nil) + (unless interrupted-p + (setq js2-mode-parse-timer nil)))))) + +;; We bound it to [mouse-1] previously. But the signature of +;; mouse-set-point changed around 24.4, so it's kind of hard to keep +;; it working in 24.1-24.3. Since the command is not hugely +;; important, we removed the binding (#356). Maybe we'll bring it +;; back when supporting <24.4 is not a goal anymore. +(defun js2-mode-show-node (event &optional promote-to-region) + "Debugging aid: highlight selected AST node on mouse click." + (interactive "e\np") + (mouse-set-point event promote-to-region) + (when js2-mode-show-overlay + (let ((node (js2-node-at-point)) + beg end) + (if (null node) + (message "No node found at location %s" (point)) + (setq beg (js2-node-abs-pos node) + end (+ beg (js2-node-len node))) + (if js2-mode-node-overlay + (move-overlay js2-mode-node-overlay beg end) + (setq js2-mode-node-overlay (make-overlay beg end)) + (overlay-put js2-mode-node-overlay 'font-lock-face 'highlight)) + (with-silent-modifications + (if (fboundp 'cursor-sensor-mode) + (put-text-property beg end 'cursor-sensor-functions + '(js2-mode-hide-overlay)) + (put-text-property beg end 'point-left #'js2-mode-hide-overlay))) + (message "%s, parent: %s" + (js2-node-short-name node) + (if (js2-node-parent node) + (js2-node-short-name (js2-node-parent node)) + "nil")))))) + +(defun js2-mode-hide-overlay (&optional arg1 arg2 _arg3) + "Remove the debugging overlay when point moves. +ARG1, ARG2 and ARG3 have different values depending on whether this function +was found on `point-left' or in `cursor-sensor-functions'." + (when js2-mode-node-overlay + (let ((beg (overlay-start js2-mode-node-overlay)) + (end (overlay-end js2-mode-node-overlay)) + (p2 (if (windowp arg1) + ;; Called from cursor-sensor-functions. + (window-point arg1) + ;; Called from point-left. + arg2))) + ;; Sometimes we're called spuriously. + (unless (and p2 + (>= p2 beg) + (<= p2 end)) + (with-silent-modifications + (remove-text-properties beg end + '(point-left nil cursor-sensor-functions))) + (delete-overlay js2-mode-node-overlay) + (setq js2-mode-node-overlay nil))))) + +(defun js2-mode-reset () + "Debugging helper: reset everything." + (interactive) + (js2-mode-exit) + (js2-mode)) + +(defun js2-mode-show-warn-or-err (e face) + "Highlight a warning or error E with FACE. +E is a list of ((MSG-KEY MSG-ARG) BEG LEN OVERRIDE-FACE). +The last element is optional. When present, use instead of FACE." + (let* ((key (cl-first e)) + (beg (cl-second e)) + (end (+ beg (cl-third e))) + ;; Don't inadvertently go out of bounds. + (beg (max (point-min) (min beg (point-max)))) + (end (max (point-min) (min end (point-max)))) + (ovl (make-overlay beg end))) + ;; FIXME: Why a mix of overlays and text-properties? + (overlay-put ovl 'font-lock-face (or (cl-fourth e) face)) + (overlay-put ovl 'js2-error t) + (put-text-property beg end 'help-echo (js2-get-msg key)) + (if (fboundp 'cursor-sensor-mode) + (put-text-property beg end 'cursor-sensor-functions '(js2-echo-error)) + (put-text-property beg end 'point-entered #'js2-echo-error)))) + +(defun js2-remove-overlays () + "Remove overlays from buffer that have a `js2-error' property." + (let ((beg (point-min)) + (end (point-max))) + (save-excursion + (dolist (o (overlays-in beg end)) + (when (overlay-get o 'js2-error) + (delete-overlay o)))))) + +(defun js2-mode-apply-deferred-properties () + "Apply fontifications and other text properties recorded during parsing." + (when (cl-plusp js2-highlight-level) + ;; We defer clearing faces as long as possible to eliminate flashing. + (js2-clear-face (point-min) (point-max)) + ;; Have to reverse the recorded fontifications list so that errors + ;; and warnings overwrite the normal fontifications. + (dolist (f (nreverse js2-mode-fontifications)) + (put-text-property (cl-first f) (cl-second f) 'font-lock-face (cl-third f))) + (setq js2-mode-fontifications nil)) + (dolist (p js2-mode-deferred-properties) + (apply #'put-text-property p)) + (setq js2-mode-deferred-properties nil)) + +(defun js2-mode-show-errors () + "Highlight syntax errors." + (when js2-mode-show-parse-errors + (dolist (e (js2-ast-root-errors js2-mode-ast)) + (js2-mode-show-warn-or-err e 'js2-error)))) + +(defun js2-mode-remove-suppressed-warnings () + "Take suppressed warnings out of the AST warnings list. +This ensures that the counts and `next-error' are correct." + (setf (js2-ast-root-warnings js2-mode-ast) + (js2-delete-if + (lambda (e) + (let ((key (caar e))) + (or + (and (not js2-strict-trailing-comma-warning) + (string-match "trailing\\.comma" key)) + (and (not js2-strict-cond-assign-warning) + (string= key "msg.equal.as.assign")) + (and js2-missing-semi-one-line-override + (string= key "msg.missing.semi") + (let* ((beg (cl-second e)) + (node (js2-node-at-point beg)) + (fn (js2-mode-find-parent-fn node)) + (body (and fn (js2-function-node-body fn))) + (lc (and body (js2-node-abs-pos body))) + (rc (and lc (+ lc (js2-node-len body))))) + (and fn + (or (null body) + (save-excursion + (goto-char beg) + (and (js2-same-line lc) + (js2-same-line rc)))))))))) + (js2-ast-root-warnings js2-mode-ast)))) + +(defun js2-mode-show-warnings () + "Highlight strict-mode warnings." + (when js2-mode-show-strict-warnings + (dolist (e (js2-ast-root-warnings js2-mode-ast)) + (js2-mode-show-warn-or-err e 'js2-warning)))) + +(defun js2-echo-error (arg1 arg2 &optional _arg3) + "Called by point-motion hooks. +ARG1, ARG2 and ARG3 have different values depending on whether this function +was found on `point-entered' or in `cursor-sensor-functions'." + (let* ((new-point (if (windowp arg1) + ;; Called from cursor-sensor-functions. + (window-point arg1) + ;; Called from point-left. + arg2)) + (msg (get-text-property new-point 'help-echo))) + (when (and (stringp msg) + (not (active-minibuffer-window)) + (not (current-message))) + (message msg)))) + +(defun js2-line-break (&optional _soft) + "Break line at point and indent, continuing comment if within one. +If inside a string, and `js2-concat-multiline-strings' is not +nil, turn it into concatenation." + (interactive) + (let ((parse-status (syntax-ppss))) + (cond + ;; Check if we're inside a string. + ((nth 3 parse-status) + (if js2-concat-multiline-strings + (js2-mode-split-string parse-status) + (insert "\n"))) + ;; Check if inside a block comment. + ((nth 4 parse-status) + (js2-mode-extend-comment (nth 8 parse-status))) + (t + (newline-and-indent))))) + +(defun js2-mode-split-string (parse-status) + "Turn a newline in mid-string into a string concatenation. +PARSE-STATUS is as documented in `parse-partial-sexp'." + (let* ((quote-char (nth 3 parse-status)) + (at-eol (eq js2-concat-multiline-strings 'eol))) + (insert quote-char) + (insert (if at-eol " +\n" "\n")) + (unless at-eol + (insert "+ ")) + (js2-indent-line) + (insert quote-char) + (when (eolp) + (insert quote-char) + (backward-char 1)))) + +(defun js2-mode-extend-comment (start-pos) + "Indent the line and, when inside a comment block, add comment prefix." + (let (star single col first-line needs-close) + (save-excursion + (back-to-indentation) + (when (< (point) start-pos) + (goto-char start-pos)) + (cond + ((looking-at "\\*[^/]") + (setq star t + col (current-column))) + ((looking-at "/\\*") + (setq star t + first-line t + col (1+ (current-column)))) + ((looking-at "//") + (setq single t + col (current-column))))) + ;; Heuristic for whether we need to close the comment: + ;; if we've got a parse error here, assume it's an unterminated + ;; comment. + (setq needs-close + (or + (get-char-property (1- (point)) 'js2-error) + ;; The heuristic above doesn't work well when we're + ;; creating a comment and there's another one downstream, + ;; as our parser thinks this one ends at the end of the + ;; next one. (You can have a /* inside a js block comment.) + ;; So just close it if the next non-ws char isn't a *. + (and first-line + (eolp) + (save-excursion + (skip-chars-forward " \t\r\n") + (not (eq (char-after) ?*)))))) + (delete-horizontal-space) + (insert "\n") + (cond + (star + (indent-to col) + (insert "* ") + (if (and first-line needs-close) + (save-excursion + (insert "\n") + (indent-to col) + (insert "*/")))) + (single + (indent-to col) + (insert "// "))) + ;; Don't need to extend the comment after all. + (js2-indent-line))) + +(defun js2-beginning-of-line () + "Toggle point between bol and first non-whitespace char in line. +Also moves past comment delimiters when inside comments." + (interactive) + (let (node) + (cond + ((bolp) + (back-to-indentation)) + ((looking-at "//") + (skip-chars-forward "/ \t")) + ((and (eq (char-after) ?*) + (setq node (js2-comment-at-point)) + (memq (js2-comment-node-format node) '(jsdoc block)) + (save-excursion + (skip-chars-backward " \t") + (bolp))) + (skip-chars-forward "\* \t")) + (t + (goto-char (point-at-bol)))))) + +(defun js2-end-of-line () + "Toggle point between eol and last non-whitespace char in line." + (interactive) + (if (eolp) + (skip-chars-backward " \t") + (goto-char (point-at-eol)))) + +(defun js2-mode-wait-for-parse (callback) + "Invoke CALLBACK when parsing is finished. +If parsing is already finished, calls CALLBACK immediately." + (if (not js2-mode-buffer-dirty-p) + (funcall callback) + (push callback js2-mode-pending-parse-callbacks) + (add-hook 'js2-parse-finished-hook #'js2-mode-parse-finished))) + +(defun js2-mode-parse-finished () + "Invoke callbacks in `js2-mode-pending-parse-callbacks'." + ;; We can't let errors propagate up, since it prevents the + ;; `js2-parse' method from completing normally and returning + ;; the ast, which makes things mysteriously not work right. + (unwind-protect + (dolist (cb js2-mode-pending-parse-callbacks) + (condition-case err + (funcall cb) + (error (message "%s" err)))) + (setq js2-mode-pending-parse-callbacks nil))) + +(defun js2-mode-flag-region (from to flag) + "Hide or show text from FROM to TO, according to FLAG. +If FLAG is nil then text is shown, while if FLAG is t the text is hidden. +Returns the created overlay if FLAG is non-nil." + (remove-overlays from to 'invisible 'js2-outline) + (when flag + (let ((o (make-overlay from to))) + (overlay-put o 'invisible 'js2-outline) + (overlay-put o 'isearch-open-invisible + 'js2-isearch-open-invisible) + o))) + +;; Function to be set as an outline-isearch-open-invisible' property +;; to the overlay that makes the outline invisible (see +;; `js2-mode-flag-region'). +(defun js2-isearch-open-invisible (_overlay) + ;; We rely on the fact that isearch places point on the matched text. + (js2-mode-show-element)) + +(defun js2-mode-invisible-overlay-bounds (&optional pos) + "Return cons cell of bounds of folding overlay at POS. +Returns nil if not found." + (let ((overlays (overlays-at (or pos (point)))) + o) + (while (and overlays + (not o)) + (if (overlay-get (car overlays) 'invisible) + (setq o (car overlays)) + (setq overlays (cdr overlays)))) + (if o + (cons (overlay-start o) (overlay-end o))))) + +(defun js2-mode-function-at-point (&optional pos) + "Return the innermost function node enclosing current point. +Returns nil if point is not in a function." + (let ((node (js2-node-at-point pos))) + (while (and node (not (js2-function-node-p node))) + (setq node (js2-node-parent node))) + (if (js2-function-node-p node) + node))) + +(defun js2-mode-toggle-element () + "Hide or show the foldable element at the point." + (interactive) + (let (comment fn pos) + (save-excursion + (cond + ;; /* ... */ comment? + ((js2-block-comment-p (setq comment (js2-comment-at-point))) + (if (js2-mode-invisible-overlay-bounds + (setq pos (+ 3 (js2-node-abs-pos comment)))) + (progn + (goto-char pos) + (js2-mode-show-element)) + (js2-mode-hide-element))) + ;; //-comment? + ((save-excursion + (back-to-indentation) + (looking-at js2-mode-//-comment-re)) + (js2-mode-toggle-//-comment)) + ;; function? + ((setq fn (js2-mode-function-at-point)) + (setq pos (and (js2-function-node-body fn) + (js2-node-abs-pos (js2-function-node-body fn)))) + (goto-char (1+ pos)) + (if (js2-mode-invisible-overlay-bounds) + (js2-mode-show-element) + (js2-mode-hide-element))) + (t + (message "Nothing at point to hide or show")))))) + +(defun js2-mode-hide-element () + "Fold/hide contents of a block, showing ellipses. +Show the hidden text with \\[js2-mode-show-element]." + (interactive) + (if js2-mode-buffer-dirty-p + (js2-mode-wait-for-parse #'js2-mode-hide-element)) + (let (node body beg end) + (cond + ((js2-mode-invisible-overlay-bounds) + (message "already hidden")) + (t + (setq node (js2-node-at-point)) + (cond + ((js2-block-comment-p node) + (js2-mode-hide-comment node)) + (t + (while (and node (not (js2-function-node-p node))) + (setq node (js2-node-parent node))) + (if (and node + (setq body (js2-function-node-body node))) + (progn + (setq beg (js2-node-abs-pos body) + end (+ beg (js2-node-len body))) + (js2-mode-flag-region (1+ beg) (1- end) 'hide)) + (message "No collapsable element found at point")))))))) + +(defun js2-mode-show-element () + "Show the hidden element at current point." + (interactive) + (let ((bounds (js2-mode-invisible-overlay-bounds))) + (if bounds + (js2-mode-flag-region (car bounds) (cdr bounds) nil) + (message "Nothing to un-hide")))) + +(defun js2-mode-show-all () + "Show all of the text in the buffer." + (interactive) + (js2-mode-flag-region (point-min) (point-max) nil)) + +(defun js2-mode-toggle-hide-functions () + (interactive) + (if js2-mode-functions-hidden + (js2-mode-show-functions) + (js2-mode-hide-functions))) + +(defun js2-mode-hide-functions () + "Hides all non-nested function bodies in the buffer. +Use \\[js2-mode-show-all] to reveal them, or \\[js2-mode-show-element] +to open an individual entry." + (interactive) + (if js2-mode-buffer-dirty-p + (js2-mode-wait-for-parse #'js2-mode-hide-functions)) + (if (null js2-mode-ast) + (message "Oops - parsing failed") + (setq js2-mode-functions-hidden t) + (js2-visit-ast js2-mode-ast #'js2-mode-function-hider))) + +(defun js2-mode-function-hider (n endp) + (when (not endp) + (let ((tt (js2-node-type n)) + body beg end) + (cond + ((and (= tt js2-FUNCTION) + (setq body (js2-function-node-body n))) + (setq beg (js2-node-abs-pos body) + end (+ beg (js2-node-len body))) + (js2-mode-flag-region (1+ beg) (1- end) 'hide) + nil) ; don't process children of function + (t + t))))) ; keep processing other AST nodes + +(defun js2-mode-show-functions () + "Un-hide any folded function bodies in the buffer." + (interactive) + (setq js2-mode-functions-hidden nil) + (save-excursion + (goto-char (point-min)) + (while (/= (goto-char (next-overlay-change (point))) + (point-max)) + (dolist (o (overlays-at (point))) + (when (and (overlay-get o 'invisible) + (not (overlay-get o 'comment))) + (js2-mode-flag-region (overlay-start o) (overlay-end o) nil)))))) + +(defun js2-mode-hide-comment (n) + (let* ((head (if (eq (js2-comment-node-format n) 'jsdoc) + 3 ; /** + 2)) ; /* + (beg (+ (js2-node-abs-pos n) head)) + (end (- (+ beg (js2-node-len n)) head 2)) + (o (js2-mode-flag-region beg end 'hide))) + (overlay-put o 'comment t))) + +(defun js2-mode-toggle-hide-comments () + "Folds all block comments in the buffer. +Use \\[js2-mode-show-all] to reveal them, or \\[js2-mode-show-element] +to open an individual entry." + (interactive) + (if js2-mode-comments-hidden + (js2-mode-show-comments) + (js2-mode-hide-comments))) + +(defun js2-mode-hide-comments () + (interactive) + (if js2-mode-buffer-dirty-p + (js2-mode-wait-for-parse #'js2-mode-hide-comments)) + (if (null js2-mode-ast) + (message "Oops - parsing failed") + (setq js2-mode-comments-hidden t) + (dolist (n (js2-ast-root-comments js2-mode-ast)) + (when (js2-block-comment-p n) + (js2-mode-hide-comment n))) + (js2-mode-hide-//-comments))) + +(defun js2-mode-extend-//-comment (direction) + "Find start or end of a block of similar //-comment lines. +DIRECTION is -1 to look back, 1 to look forward. +INDENT is the indentation level to match. +Returns the end-of-line position of the furthest adjacent +//-comment line with the same indentation as the current line. +If there is no such matching line, returns current end of line." + (let ((pos (point-at-eol)) + (indent (current-indentation))) + (save-excursion + (while (and (zerop (forward-line direction)) + (looking-at js2-mode-//-comment-re) + (eq indent (length (match-string 1)))) + (setq pos (point-at-eol))) + pos))) + +(defun js2-mode-hide-//-comments () + "Fold adjacent 1-line comments, showing only snippet of first one." + (let (beg end) + (save-excursion + (goto-char (point-min)) + (while (re-search-forward js2-mode-//-comment-re nil t) + (setq beg (point) + end (js2-mode-extend-//-comment 1)) + (unless (eq beg end) + (overlay-put (js2-mode-flag-region beg end 'hide) + 'comment t)) + (goto-char end) + (forward-char 1))))) + +(defun js2-mode-toggle-//-comment () + "Fold or un-fold any multi-line //-comment at point. +Caller should have determined that this line starts with a //-comment." + (let* ((beg (point-at-eol)) + (end beg)) + (save-excursion + (goto-char end) + (if (js2-mode-invisible-overlay-bounds) + (js2-mode-show-element) + ;; else hide the comment + (setq beg (js2-mode-extend-//-comment -1) + end (js2-mode-extend-//-comment 1)) + (unless (eq beg end) + (overlay-put (js2-mode-flag-region beg end 'hide) + 'comment t)))))) + +(defun js2-mode-show-comments () + "Un-hide any hidden comments, leaving other hidden elements alone." + (interactive) + (setq js2-mode-comments-hidden nil) + (save-excursion + (goto-char (point-min)) + (while (/= (goto-char (next-overlay-change (point))) + (point-max)) + (dolist (o (overlays-at (point))) + (when (overlay-get o 'comment) + (js2-mode-flag-region (overlay-start o) (overlay-end o) nil)))))) + +(defun js2-mode-display-warnings-and-errors () + "Turn on display of warnings and errors." + (interactive) + (setq js2-mode-show-parse-errors t + js2-mode-show-strict-warnings t) + (js2-reparse 'force)) + +(defun js2-mode-hide-warnings-and-errors () + "Turn off display of warnings and errors." + (interactive) + (setq js2-mode-show-parse-errors nil + js2-mode-show-strict-warnings nil) + (js2-reparse 'force)) + +(defun js2-mode-toggle-warnings-and-errors () + "Toggle the display of warnings and errors. +Some users don't like having warnings/errors reported while they type." + (interactive) + (setq js2-mode-show-parse-errors (not js2-mode-show-parse-errors) + js2-mode-show-strict-warnings (not js2-mode-show-strict-warnings)) + (if (called-interactively-p 'any) + (message "warnings and errors %s" + (if js2-mode-show-parse-errors + "enabled" + "disabled"))) + (js2-reparse 'force)) + +(defun js2-mode-customize () + (interactive) + (customize-group 'js2-mode)) + +(defun js2-mode-forward-sexp (&optional arg) + "Move forward across one statement or balanced expression. +With ARG, do it that many times. Negative arg -N means +move backward across N balanced expressions." + (interactive "p") + (setq arg (or arg 1)) + (save-restriction + (widen) ;; `blink-matching-open' calls `narrow-to-region' + (js2-reparse) + (let (forward-sexp-function + node (start (point)) pos lp rp child) + (cond + ((js2-string-node-p (js2-node-at-point)) + (forward-sexp arg)) + ;; backward-sexp + ;; could probably make this better for some cases: + ;; - if in statement block (e.g. function body), go to parent + ;; - infix exprs like (foo in bar) - maybe go to beginning + ;; of infix expr if in the right-side expression? + ((and arg (cl-minusp arg)) + (dotimes (_ (- arg)) + (js2-backward-sws) + (forward-char -1) ; Enter the node we backed up to. + (when (setq node (js2-node-at-point (point) t)) + (setq pos (js2-node-abs-pos node)) + (let ((parens (js2-mode-forward-sexp-parens node pos))) + (setq lp (car parens) + rp (cdr parens))) + (when (and lp (> start lp)) + (if (and rp (<= start rp)) + ;; Between parens, check if there's a child node we can jump. + (when (setq child (js2-node-closest-child node (point) lp t)) + (setq pos (js2-node-abs-pos child))) + ;; Before both parens. + (setq pos lp))) + (let ((state (parse-partial-sexp start pos))) + (goto-char (if (not (zerop (car state))) + ;; Stumble at the unbalanced paren if < 0, or + ;; jump a bit further if > 0. + (scan-sexps start -1) + pos)))) + (unless pos (goto-char (point-min))))) + (t + ;; forward-sexp + (dotimes (_ arg) + (js2-forward-sws) + (when (setq node (js2-node-at-point (point) t)) + (setq pos (js2-node-abs-pos node)) + (let ((parens (js2-mode-forward-sexp-parens node pos))) + (setq lp (car parens) + rp (cdr parens))) + (or + (when (and rp (<= start rp)) + (if (> start lp) + (when (setq child (js2-node-closest-child node (point) rp)) + (setq pos (js2-node-abs-end child))) + (setq pos (1+ rp)))) + ;; No parens or child nodes, looks for the end of the current node. + (cl-incf pos (js2-node-len + (if (js2-expr-stmt-node-p (js2-node-parent node)) + ;; Stop after the semicolon. + (js2-node-parent node) + node)))) + (let ((state (save-excursion (parse-partial-sexp start pos)))) + (goto-char (if (not (zerop (car state))) + (scan-sexps start 1) + pos)))) + (unless pos (goto-char (point-max))))))))) + +(defun js2-mode-forward-sexp-parens (node abs-pos) + "Return a cons cell with positions of main parens in NODE." + (cond + ((or (js2-array-node-p node) + (js2-object-node-p node) + (js2-comp-node-p node) + (memq (aref node 0) '(cl-struct-js2-block-node cl-struct-js2-scope))) + (cons abs-pos (+ abs-pos (js2-node-len node) -1))) + ((js2-paren-expr-node-p node) + (let ((lp (js2-node-lp node)) + (rp (js2-node-rp node))) + (cons (when lp (+ abs-pos lp)) + (when rp (+ abs-pos rp))))))) + +(defun js2-node-closest-child (parent point limit &optional before) + (let* ((parent-pos (js2-node-abs-pos parent)) + (rpoint (- point parent-pos)) + (rlimit (- limit parent-pos)) + (min (min rpoint rlimit)) + (max (max rpoint rlimit)) + found) + (catch 'done + (js2-visit-ast + parent + (lambda (node _end-p) + (if (eq node parent) + t + (let ((pos (js2-node-pos node)) ;; Both relative values. + (end (+ (js2-node-pos node) (js2-node-len node)))) + (when (and (>= pos min) (<= end max) + (if before (< pos rpoint) (> end rpoint))) + (setq found node)) + (when (> end rpoint) + (throw 'done nil))) + nil)))) + found)) + +(defun js2-errors () + "Return a list of errors found." + (and js2-mode-ast + (js2-ast-root-errors js2-mode-ast))) + +(defun js2-warnings () + "Return a list of warnings found." + (and js2-mode-ast + (js2-ast-root-warnings js2-mode-ast))) + +(defun js2-have-errors-p () + "Return non-nil if any parse errors or warnings were found." + (or (js2-errors) (js2-warnings))) + +(defun js2-errors-and-warnings () + "Return a copy of the concatenated errors and warnings lists. +They are appended: first the errors, then the warnings. +Entries are of the form (MSG BEG END)." + (when js2-mode-ast + (append (js2-ast-root-errors js2-mode-ast) + (copy-sequence (js2-ast-root-warnings js2-mode-ast))))) + +(defun js2-next-error (&optional arg reset) + "Move to next parse error. +Typically invoked via \\[next-error]. +ARG is the number of errors, forward or backward, to move. +RESET means start over from the beginning." + (interactive "p") + (if (not (or (js2-errors) (js2-warnings))) + (message "No errors") + (when reset + (goto-char (point-min))) + (let* ((errs (js2-errors-and-warnings)) + (continue t) + (start (point)) + (count (or arg 1)) + (backward (cl-minusp count)) + (sorter (if backward '> '<)) + (stopper (if backward '< '>)) + (count (abs count)) + all-errs err) + ;; Sort by start position. + (setq errs (sort errs (lambda (e1 e2) + (funcall sorter (cl-second e1) (cl-second e2)))) + all-errs errs) + ;; Find nth error with pos > start. + (while (and errs continue) + (when (funcall stopper (cl-cadar errs) start) + (setq err (car errs)) + (if (zerop (cl-decf count)) + (setq continue nil))) + (setq errs (cdr errs))) + ;; Clear for `js2-echo-error'. + (message nil) + (if err + (goto-char (cl-second err)) + ;; Wrap around to first error. + (goto-char (cl-second (car all-errs))) + ;; If we were already on it, echo msg again. + (if (= (point) start) + (js2-echo-error (point) (point))))))) + +(defun js2-down-mouse-3 () + "Make right-click move the point to the click location. +This makes right-click context menu operations a bit more intuitive. +The point will not move if the region is active, however, to avoid +destroying the region selection." + (interactive) + (when (and js2-move-point-on-right-click + (not mark-active)) + (let ((e last-input-event)) + (ignore-errors + (goto-char (cl-cadadr e)))))) + +(defun js2-mode-create-imenu-index () + "Returns an alist for `imenu--index-alist'. Returns nil on first +scan if buffer size > `imenu-auto-rescan-maxout'." + (when (and (not js2-mode-ast) + (<= (buffer-size) imenu-auto-rescan-maxout)) + (js2-reparse)) + (when js2-mode-ast + ;; if we have an ast but no recorder, they're requesting a rescan + (unless js2-imenu-recorder + (js2-reparse 'force)) + (prog1 + (js2-build-imenu-index) + (setq js2-imenu-recorder nil + js2-imenu-function-map nil)))) + +(defun js2-mode-find-tag () + "Replacement for `find-tag-default'. +`find-tag-default' returns a ridiculous answer inside comments." + (let (beg end) + (save-excursion + (if (looking-at "\\_>") + (setq beg (progn (forward-symbol -1) (point)) + end (progn (forward-symbol 1) (point))) + (setq beg (progn (forward-symbol 1) (point)) + end (progn (forward-symbol -1) (point)))) + (replace-regexp-in-string + "[\"']" "" + (buffer-substring-no-properties beg end))))) + +(defun js2-mode-forward-sibling () + "Move to the end of the sibling following point in parent. +Returns non-nil if successful, or nil if there was no following sibling." + (let* ((node (js2-node-at-point)) + (parent (js2-mode-find-enclosing-fn node)) + sib) + (when (setq sib (js2-node-find-child-after (point) parent)) + (goto-char (+ (js2-node-abs-pos sib) + (js2-node-len sib)))))) + +(defun js2-mode-backward-sibling () + "Move to the beginning of the sibling node preceding point in parent. +Parent is defined as the enclosing script or function." + (let* ((node (js2-node-at-point)) + (parent (js2-mode-find-enclosing-fn node)) + sib) + (when (setq sib (js2-node-find-child-before (point) parent)) + (goto-char (js2-node-abs-pos sib))))) + +(defun js2-beginning-of-defun (&optional arg) + "Go to line on which current function starts, and return t on success. +If we're not in a function or already at the beginning of one, go +to beginning of previous script-level element. +With ARG N, do that N times. If N is negative, move forward." + (setq arg (or arg 1)) + (if (cl-plusp arg) + (let ((parent (js2-node-parent-script-or-fn (js2-node-at-point)))) + (when (cond + ((js2-function-node-p parent) + (goto-char (js2-node-abs-pos parent))) + (t + (js2-mode-backward-sibling))) + (if (> arg 1) + (js2-beginning-of-defun (1- arg)) + t))) + (when (js2-end-of-defun) + (js2-beginning-of-defun (if (>= arg -1) 1 (1+ arg)))))) + +(defun js2-end-of-defun () + "Go to the char after the last position of the current function +or script-level element." + (let* ((node (js2-node-at-point)) + (parent (or (and (js2-function-node-p node) node) + (js2-node-parent-script-or-fn node))) + script) + (unless (js2-function-node-p parent) + ;; Use current script-level node, or, if none, the next one. + (setq script (or parent node) + parent (js2-node-find-child-before (point) script)) + (when (or (null parent) + (>= (point) (+ (js2-node-abs-pos parent) + (js2-node-len parent)))) + (setq parent (js2-node-find-child-after (point) script)))) + (when parent + (goto-char (+ (js2-node-abs-pos parent) + (js2-node-len parent)))))) + +(defun js2-mark-defun (&optional allow-extend) + "Put mark at end of this function, point at beginning. +The function marked is the one that contains point. + +Interactively, if this command is repeated, +or (in Transient Mark mode) if the mark is active, +it marks the next defun after the ones already marked." + (interactive "p") + (let (extended) + (when (and allow-extend + (or (and (eq last-command this-command) (mark t)) + (and transient-mark-mode mark-active))) + (let ((sib (save-excursion + (goto-char (mark)) + (if (js2-mode-forward-sibling) + (point))))) + (if sib + (progn + (set-mark sib) + (setq extended t)) + ;; no more siblings - try extending to enclosing node + (goto-char (mark t))))) + (when (not extended) + (let ((node (js2-node-at-point (point) t)) ; skip comments + ast fn stmt parent beg end) + (when (js2-ast-root-p node) + (setq ast node + node (or (js2-node-find-child-after (point) node) + (js2-node-find-child-before (point) node)))) + ;; only mark whole buffer if we can't find any children + (if (null node) + (setq node ast)) + (if (js2-function-node-p node) + (setq parent node) + (setq fn (js2-mode-find-enclosing-fn node) + stmt (if (or (null fn) + (js2-ast-root-p fn)) + (js2-mode-find-first-stmt node)) + parent (or stmt fn))) + (setq beg (js2-node-abs-pos parent) + end (+ beg (js2-node-len parent))) + (push-mark beg) + (goto-char end) + (exchange-point-and-mark))))) + +(defun js2-narrow-to-defun () + "Narrow to the function enclosing point." + (interactive) + (let* ((node (js2-node-at-point (point) t)) ; skip comments + (fn (if (js2-script-node-p node) + node + (js2-mode-find-enclosing-fn node))) + (beg (js2-node-abs-pos fn))) + (unless (js2-ast-root-p fn) + (narrow-to-region beg (+ beg (js2-node-len fn)))))) + +(defun js2-jump-to-definition (&optional arg) + "Jump to the definition of an object's property, variable or function." + (interactive "P") + (if (eval-when-compile (fboundp 'xref-push-marker-stack)) + (xref-push-marker-stack) + (ring-insert find-tag-marker-ring (point-marker))) + (js2-reparse) + (let* ((node (js2-node-at-point)) + (parent (js2-node-parent node)) + (names (if (js2-prop-get-node-p parent) + (reverse (let ((temp (js2-compute-nested-prop-get parent))) + (cl-loop for n in temp + with result = '() + do (push n result) + until (equal node n) + finally return result))))) + node-init) + (unless (and (js2-name-node-p node) + (not (js2-var-init-node-p parent)) + (not (js2-function-node-p parent))) + (error "Node is not a supported jump node")) + (push (or (and names (pop names)) + (unless (and (js2-object-prop-node-p parent) + (eq node (js2-object-prop-node-left parent)) + (not (js2-node-get-prop parent 'SHORTHAND))) + node) + (error "Node is not a supported jump node")) names) + (setq node-init (js2-search-scope node names)) + + ;; todo: display list of results in buffer + ;; todo: group found references by buffer + (unless node-init + (switch-to-buffer + (catch 'found + (unless arg + (mapc (lambda (b) + (with-current-buffer b + (when (derived-mode-p 'js2-mode) + (setq node-init (js2-search-scope js2-mode-ast names)) + (if node-init + (throw 'found b))))) + (buffer-list))) + nil))) + (setq node-init (if (listp node-init) (car node-init) node-init)) + (unless node-init + (pop-tag-mark) + (error "No jump location found")) + (goto-char (js2-node-abs-pos node-init)))) + +(defun js2-search-object (node name-node) + "Check if object NODE contains element with NAME-NODE." + (cl-assert (js2-object-node-p node)) + ;; Only support name-node and nodes for the time being + (cl-loop for elem in (js2-object-node-elems node) + for left = (js2-object-prop-node-left elem) + if (or (and (js2-name-node-p left) + (equal (js2-name-node-name name-node) + (js2-name-node-name left))) + (and (js2-string-node-p left) + (string= (js2-name-node-name name-node) + (js2-string-node-value left)))) + return elem)) + +(defun js2-search-object-for-prop (object prop-names) + "Return node in OBJECT that matches PROP-NAMES or nil. +PROP-NAMES is a list of values representing a path to a value in OBJECT. +i.e. (\\='name\\=' \\='value\\=') = {name : { value: 3}}" + (let (node + (temp-object object) + (temp t) ;temporay node + (names prop-names)) + (while (and temp names (js2-object-node-p temp-object)) + (setq temp (js2-search-object temp-object (pop names))) + (and (setq node temp) + (setq temp-object (js2-object-prop-node-right temp)))) + (unless names node))) + +(defun js2-search-scope (node names) + "Searches NODE scope for jump location matching NAMES. +NAMES is a list of property values to search for. For functions +and variables NAMES will contain one element." + (let (node-init + (val (js2-name-node-name (car names)))) + (setq node-init (js2-get-symbol-declaration node val)) + + (when (> (length names) 1) + + ;; Check var declarations + (when (and node-init (string= val (js2-name-node-name node-init))) + (let ((parent (js2-node-parent node-init)) + (temp-names names)) + (pop temp-names) ;; First element is var name + (setq node-init (when (js2-var-init-node-p parent) + (js2-search-object-for-prop + (js2-var-init-node-initializer parent) + temp-names))))) + + ;; Check all assign nodes + (js2-visit-ast + js2-mode-ast + (lambda (node endp) + (unless endp + (if (js2-assign-node-p node) + (let ((left (js2-assign-node-left node)) + (right (js2-assign-node-right node)) + (temp-names names)) + (when (js2-prop-get-node-p left) + (let* ((prop-list (js2-compute-nested-prop-get left)) + (found (cl-loop for prop in prop-list + until (not (string= (js2-name-node-name + (pop temp-names)) + (js2-name-node-name prop))) + if (not temp-names) return prop)) + (found-node (or found + (when (js2-object-node-p right) + (js2-search-object-for-prop right + temp-names))))) + (if found-node (push found-node node-init)))))) + t)))) + node-init)) + +(defun js2-get-symbol-declaration (node name) + "Find scope for NAME from NODE." + (let ((scope (js2-get-defining-scope + (or (js2-node-get-enclosing-scope node) + node) name))) + (if scope (js2-symbol-ast-node (js2-scope-get-symbol scope name))))) + +(provide 'js2-mode) + +;;; js2-mode.el ends here
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/js2-old-indent.el @@ -0,0 +1,712 @@ +;;; js2-old-indent.el --- Indentation code kept for compatibility + +;; Copyright (C) 2015 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Commentary: + +;; All features of this indentation code have been ported to Emacs's +;; built-in `js-mode' by now, so we derive from it. An older +;; commentary follows. + +;; This code is kept for Emacs 24.5 and ealier. + +;; This indenter is based on Karl Landström's "javascript.el" indenter. +;; Karl cleverly deduces that the desired indentation level is often a +;; function of paren/bracket/brace nesting depth, which can be determined +;; quickly via the built-in `parse-partial-sexp' function. His indenter +;; then does some equally clever checks to see if we're in the context of a +;; substatement of a possibly braceless statement keyword such as if, while, +;; or finally. This approach yields pretty good results. + +;; The indenter is often "wrong", however, and needs to be overridden. +;; The right long-term solution is probably to emulate (or integrate +;; with) cc-engine, but it's a nontrivial amount of coding. Even when a +;; parse tree from `js2-parse' is present, which is not true at the +;; moment the user is typing, computing indentation is still thousands +;; of lines of code to handle every possible syntactic edge case. + +;; In the meantime, the compromise solution is that we offer a "bounce +;; indenter", configured with `js2-bounce-indent-p', which cycles the +;; current line indent among various likely guess points. This approach +;; is far from perfect, but should at least make it slightly easier to +;; move the line towards its desired indentation when manually +;; overriding Karl's heuristic nesting guesser. + +;; I've made miscellaneous tweaks to Karl's code to handle some Ecma +;; extensions such as `let' and Array comprehensions. Major kudos to +;; Karl for coming up with the initial approach, which packs a lot of +;; punch for so little code. -- Steve + +;;; Code: + +(require 'sgml-mode) + +(defvar js2-language-version) + +(declare-function js2-backward-sws "js2-mode") +(declare-function js2-forward-sws "js2-mode") +(declare-function js2-same-line "js2-mode") + +(defcustom js2-basic-offset (if (and (boundp 'c-basic-offset) + (numberp c-basic-offset)) + c-basic-offset + 4) + "Number of spaces to indent nested statements. +Similar to `c-basic-offset'." + :group 'js2-mode + :safe 'integerp + :type 'integer) + +(defcustom js2-pretty-multiline-declarations t + "Non-nil to line up multiline declarations vertically: + + var a = 10, + b = 20, + c = 30; + +If the value is t, and the first assigned value in the +declaration is a function/array/object literal spanning several +lines, it won't be indented additionally: + + var o = { var bar = 2, + foo: 3 vs. o = { + }, foo: 3 + bar = 2; }; + +If the value is `all', it will always be indented additionally: + + var o = { + foo: 3 + }; + + var o = { + foo: 3 + }, + bar = 2; + +If the value is `dynamic', it will be indented additionally only +if the declaration contains more than one variable: + + var o = { + foo: 3 + }; + + var o = { + foo: 3 + }, + bar = 2;" + :group 'js2-mode + :safe 'symbolp + :type 'symbol) + +(defcustom js2-indent-switch-body nil + "When nil, case labels are indented on the same level as the +containing switch statement. Otherwise, all lines inside +switch statement body are indented one additional level." + :type 'boolean + :safe 'booleanp + :group 'js2-mode) + +(defconst js2-possibly-braceless-keywords-re + (concat "else[ \t]+if\\|for[ \t]+each\\|" + (regexp-opt '("catch" "do" "else" "finally" "for" "if" + "try" "while" "with" "let"))) + "Regular expression matching keywords that are optionally +followed by an opening brace.") + +(defconst js2-indent-operator-re + (concat "[-+*/%<>&^|?:.]\\([^-+*/.]\\|$\\)\\|!?=\\|" + (regexp-opt '("in" "instanceof") 'symbols)) + "Regular expression matching operators that affect indentation +of continued expressions.") + +(defconst js2-declaration-keyword-re + (regexp-opt '("var" "let" "const") 'symbols) + "Regular expression matching variable declaration keywords.") + +(defun js2-re-search-forward-inner (regexp &optional bound count) + "Auxiliary function for `js2-re-search-forward'." + (let (parse saved-point) + (while (> count 0) + (re-search-forward regexp bound) + (setq parse (if saved-point + (parse-partial-sexp saved-point (point)) + (syntax-ppss (point)))) + (cond ((nth 3 parse) + (re-search-forward + (concat "\\(\\=\\|[^\\]\\|^\\)" (string (nth 3 parse))) + (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)))) + (setq saved-point (point)))) + (point)) + +(defun js2-re-search-forward (regexp &optional bound noerror count) + "Search forward but ignore strings and comments. +Invokes `re-search-forward' but treats the buffer as if strings +and comments have been removed." + (let ((saved-point (point))) + (condition-case err + (cond ((null count) + (js2-re-search-forward-inner regexp bound 1)) + ((< count 0) + (js2-re-search-backward-inner regexp bound (- count))) + ((> count 0) + (js2-re-search-forward-inner regexp bound count))) + (search-failed + (goto-char saved-point) + (unless noerror + (error (error-message-string err))))))) + +(defun js2-re-search-backward-inner (regexp &optional bound count) + "Auxiliary function for `js2-re-search-backward'." + (let (parse) + (while (> count 0) + (re-search-backward regexp bound) + (setq parse (syntax-ppss (point))) + (cond ((nth 3 parse) + (re-search-backward + (concat "\\([^\\]\\|^\\)" (string (nth 3 parse))) + (line-beginning-position) t)) + ((nth 7 parse) + (goto-char (nth 8 parse))) + ((or (nth 4 parse) + (and (eq (char-before) ?/) (eq (char-after) ?*))) + (re-search-backward "/\\*")) + (t + (setq count (1- count)))))) + (point)) + +(defun js2-re-search-backward (regexp &optional bound noerror count) + "Search backward but ignore strings and comments. +Invokes `re-search-backward' but treats the buffer as if strings +and comments have been removed." + (let ((saved-point (point))) + (condition-case err + (cond ((null count) + (js2-re-search-backward-inner regexp bound 1)) + ((< count 0) + (js2-re-search-forward-inner regexp bound (- count))) + ((> count 0) + (js2-re-search-backward-inner regexp bound count))) + (search-failed + (goto-char saved-point) + (unless noerror + (error (error-message-string err))))))) + +(defun js2-looking-at-operator-p () + "Return non-nil if text after point is a non-comma operator." + (defvar js2-mode-identifier-re) + (and (looking-at js2-indent-operator-re) + (or (not (eq (char-after) ?:)) + (save-excursion + (and (js2-re-search-backward "[?:{]\\|\\_<case\\_>" nil t) + (eq (char-after) ??)))) + (not (and + (eq (char-after) ?/) + (save-excursion + (eq (nth 3 (syntax-ppss)) ?/)))) + (not (and + (eq (char-after) ?*) + ;; Generator method (possibly using computed property). + (looking-at (concat "\\* *\\(?:\\[\\|" + js2-mode-identifier-re + " *(\\)")) + (save-excursion + (js2-backward-sws) + ;; We might misindent some expressions that would + ;; return NaN anyway. Shouldn't be a problem. + (memq (char-before) '(?, ?} ?{))))))) + +(defun js2-continued-expression-p () + "Return non-nil if the current line continues an expression." + (save-excursion + (back-to-indentation) + (if (js2-looking-at-operator-p) + (or (not (memq (char-after) '(?- ?+))) + (progn + (forward-comment (- (point))) + (not (memq (char-before) '(?, ?\[ ?\())))) + (forward-comment (- (point))) + (or (bobp) (backward-char)) + (when (js2-looking-at-operator-p) + (backward-char) + (not (looking-at "\\*\\|\\+\\+\\|--\\|/[/*]")))))) + +(defun js2-end-of-do-while-loop-p () + "Return non-nil if word after point is `while' of a do-while +statement, else returns 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 + (when (looking-at "\\s-*\\_<while\\_>") + (if (save-excursion + (skip-chars-backward "[ \t\n]*}") + (looking-at "[ \t\n]*}")) + (save-excursion + (backward-list) (backward-word 1) (looking-at "\\_<do\\_>")) + (js2-re-search-backward "\\_<do\\_>" (point-at-bol) t) + (or (looking-at "\\_<do\\_>") + (let ((saved-indent (current-indentation))) + (while (and (js2-re-search-backward "^[ \t]*\\_<" nil t) + (/= (current-indentation) saved-indent))) + (and (looking-at "[ \t]*\\_<do\\_>") + (not (js2-re-search-forward + "\\_<while\\_>" (point-at-eol) t)) + (= (current-indentation) saved-indent)))))))) + +(defun js2-multiline-decl-indentation () + "Return the declaration indentation column if the current line belongs +to a multiline declaration statement. See `js2-pretty-multiline-declarations'." + (let (forward-sexp-function ; use Lisp version + at-opening-bracket) + (save-excursion + (back-to-indentation) + (when (not (looking-at js2-declaration-keyword-re)) + (when (looking-at js2-indent-operator-re) + (goto-char (match-end 0))) ; continued expressions are ok + (while (and (not at-opening-bracket) + (not (bobp)) + (let ((pos (point))) + (save-excursion + (js2-backward-sws) + (or (eq (char-before) ?,) + (and (not (eq (char-before) ?\;)) + (prog2 (skip-syntax-backward ".") + (looking-at js2-indent-operator-re) + (js2-backward-sws)) + (not (eq (char-before) ?\;))) + (js2-same-line pos))))) + (condition-case _ + (backward-sexp) + (scan-error (setq at-opening-bracket t)))) + (when (looking-at js2-declaration-keyword-re) + (goto-char (match-end 0)) + (1+ (current-column))))))) + +(defun js2-ctrl-statement-indentation () + "Return the proper indentation of current line if it is a control statement. +Returns an indentation if this line starts the body of a control +statement without braces, else returns nil." + (let (forward-sexp-function) + (save-excursion + (back-to-indentation) + (when (and (not (js2-same-line (point-min))) + (not (looking-at "{")) + (js2-re-search-backward "[[:graph:]]" nil t) + (not (looking-at "[{([]")) + (progn + (forward-char) + (when (= (char-before) ?\)) + ;; scan-sexps sometimes throws an error + (ignore-errors (backward-sexp)) + (skip-chars-backward " \t" (point-at-bol))) + (let ((pt (point))) + (back-to-indentation) + (when (looking-at "}[ \t]*") + (goto-char (match-end 0))) + (and (looking-at js2-possibly-braceless-keywords-re) + (= (match-end 0) pt) + (not (js2-end-of-do-while-loop-p)))))) + (+ (current-indentation) js2-basic-offset))))) + +(defun js2-indent-in-array-comp (parse-status) + "Return non-nil if we think we're in an array comprehension. +In particular, return the buffer position of the first `for' kwd." + (let ((bracket (nth 1 parse-status)) + (end (point))) + (when bracket + (save-excursion + (goto-char bracket) + (when (looking-at "\\[") + (forward-char 1) + (js2-forward-sws) + (if (looking-at "[[{]") + (let (forward-sexp-function) ; use Lisp version + (forward-sexp) ; skip destructuring form + (js2-forward-sws) + (if (and (/= (char-after) ?,) ; regular array + (looking-at "for")) + (match-beginning 0))) + ;; to skip arbitrary expressions we need the parser, + ;; so we'll just guess at it. + (if (and (> end (point)) ; not empty literal + (re-search-forward "[^,]]* \\(for\\) " end t) + ;; not inside comment or string literal + (let ((state (parse-partial-sexp bracket (point)))) + (and (= 1 (car state)) + (not (nth 8 state))))) + (match-beginning 1)))))))) + +(defun js2-array-comp-indentation (parse-status for-kwd) + (if (js2-same-line for-kwd) + ;; first continuation line + (save-excursion + (goto-char (nth 1 parse-status)) + (forward-char 1) + (skip-chars-forward " \t") + (current-column)) + (save-excursion + (goto-char for-kwd) + (current-column)))) + +(defun js2-maybe-goto-declaration-keyword-end (bracket) + "Helper function for `js2-proper-indentation'. +Depending on the value of `js2-pretty-multiline-declarations', +move point to the end of a variable declaration keyword so that +indentation is aligned to that column." + (cond + ((eq js2-pretty-multiline-declarations 'all) + (when (looking-at js2-declaration-keyword-re) + (goto-char (1+ (match-end 0))))) + ((eq js2-pretty-multiline-declarations 'dynamic) + (let (declaration-keyword-end + at-closing-bracket-p + comma-p) + (when (looking-at js2-declaration-keyword-re) + ;; Preserve the match data lest it somehow be overridden. + (setq declaration-keyword-end (match-end 0)) + (save-excursion + (goto-char bracket) + (setq at-closing-bracket-p + ;; Handle scan errors gracefully. + (condition-case nil + (progn + ;; Use the regular `forward-sexp-function' because the + ;; normal one for this mode uses the AST. + (let (forward-sexp-function) + (forward-sexp)) + t) + (error nil))) + (when at-closing-bracket-p + (js2-forward-sws) + (setq comma-p (looking-at-p ",")))) + (when comma-p + (goto-char (1+ declaration-keyword-end)))))))) + +(cl-defun js2-proper-indentation (parse-status) + "Return the proper indentation for the current line." + (save-excursion + (back-to-indentation) + (when (nth 4 parse-status) + (cl-return-from js2-proper-indentation (js2--comment-indent parse-status))) + (let* ((at-closing-bracket (looking-at "[]})]")) + (same-indent-p (or at-closing-bracket + (looking-at "\\_<case\\_>[^:]") + (and (looking-at "\\_<default:") + (save-excursion + (js2-backward-sws) + (not (memq (char-before) '(?, ?{))))))) + (continued-expr-p (js2-continued-expression-p)) + (declaration-indent (and js2-pretty-multiline-declarations + (js2-multiline-decl-indentation))) + (bracket (nth 1 parse-status)) + beg indent) + (cond + ;; indent array comprehension continuation lines specially + ((and bracket + (>= js2-language-version 170) + (not (js2-same-line bracket)) + (setq beg (js2-indent-in-array-comp parse-status)) + (>= (point) (save-excursion + (goto-char beg) + (point-at-bol)))) ; at or after first loop? + (js2-array-comp-indentation parse-status beg)) + + ((js2-ctrl-statement-indentation)) + + ((and declaration-indent continued-expr-p) + (+ declaration-indent js2-basic-offset)) + + (declaration-indent) + + (bracket + (goto-char bracket) + (cond + ((looking-at "[({[][ \t]*\\(/[/*]\\|$\\)") + (when (save-excursion (skip-chars-backward " \t\n)") + (looking-at ")")) + (backward-list)) + (back-to-indentation) + (js2-maybe-goto-declaration-keyword-end bracket) + (setq indent + (cond (same-indent-p + (current-column)) + (continued-expr-p + (+ (current-column) (* 2 js2-basic-offset))) + (t + (+ (current-column) js2-basic-offset)))) + (if (and js2-indent-switch-body + (not at-closing-bracket) + (looking-at "\\_<switch\\_>")) + (+ indent js2-basic-offset) + indent)) + (t + (unless same-indent-p + (forward-char) + (skip-chars-forward " \t")) + (current-column)))) + + (continued-expr-p js2-basic-offset) + + (t 0))))) + +(defun js2--comment-indent (parse-status) + "Indentation inside a multi-line block comment continuation line." + (save-excursion + (goto-char (nth 8 parse-status)) + (if (looking-at "/\\*") + (+ 1 (current-column)) + 0))) + +(defun js2-indent-line (&optional bounce-backwards) + "Indent the current line as JavaScript source text." + (interactive) + (let (parse-status offset + ;; Don't whine about errors/warnings when we're indenting. + ;; This has to be set before calling parse-partial-sexp below. + (inhibit-point-motion-hooks t)) + (setq parse-status (save-excursion + (syntax-ppss (point-at-bol))) + offset (- (point) (save-excursion + (back-to-indentation) + (point)))) + ;; Don't touch multiline strings. + (unless (nth 3 parse-status) + (indent-line-to (js2-proper-indentation parse-status)) + (when (cl-plusp offset) + (forward-char offset))))) + +;;; JSX Indentation + +;; The following JSX indentation code is copied basically verbatim from js.el at +;; 958da7f, except that the prefixes on the functions/variables are changed. + +(defsubst js2--jsx-find-before-tag () + "Find where JSX starts. + +Assume JSX appears in the following instances: +- Inside parentheses, when returned or as the first argument + to a function, and after a newline +- When assigned to variables or object properties, but only + on a single line +- As the N+1th argument to a function + +This is an optimized version of (re-search-backward \"[(,]\n\" +nil t), except set point to the end of the match. This logic +executes up to the number of lines in the file, so it should be +really fast to reduce that impact." + (let (pos) + (while (and (> (point) (point-min)) + (not (progn + (end-of-line 0) + (when (or (eq (char-before) 40) ; ( + (eq (char-before) 44)) ; , + (setq pos (1- (point)))))))) + pos)) + +(defconst js2--jsx-end-tag-re + (concat "</" sgml-name-re ">\\|/>") + "Find the end of a JSX element.") + +(defconst js2--jsx-after-tag-re "[),]" + "Find where JSX ends. +This complements the assumption of where JSX appears from +`js--jsx-before-tag-re', which see.") + +(defun js2--jsx-indented-element-p () + "Determine if/how the current line should be indented as JSX. + +Return `first' for the first JSXElement on its own line. +Return `nth' for subsequent lines of the first JSXElement. +Return `expression' for an embedded JS expression. +Return `after' for anything after the last JSXElement. +Return nil for non-JSX lines. + +Currently, JSX indentation supports the following styles: + +- Single-line elements (indented like normal JS): + + var element = <div></div>; + +- Multi-line elements (enclosed in parentheses): + + function () { + return ( + <div> + <div></div> + </div> + ); + } + +- Function arguments: + + React.render( + <div></div>, + document.querySelector(\\='.root\\=') + );" + (let ((current-pos (point)) + (current-line (line-number-at-pos)) + last-pos + before-tag-pos before-tag-line + tag-start-pos tag-start-line + tag-end-pos tag-end-line + after-tag-line + parens paren type) + (save-excursion + (and + ;; Determine if we're inside a jsx element + (progn + (end-of-line) + (while (and (not tag-start-pos) + (setq last-pos (js2--jsx-find-before-tag))) + (while (forward-comment 1)) + (when (= (char-after) 60) ; < + (setq before-tag-pos last-pos + tag-start-pos (point))) + (goto-char last-pos)) + tag-start-pos) + (progn + (setq before-tag-line (line-number-at-pos before-tag-pos) + tag-start-line (line-number-at-pos tag-start-pos)) + (and + ;; A "before" line which also starts an element begins with js, so + ;; indent it like js + (> current-line before-tag-line) + ;; Only indent the jsx lines like jsx + (>= current-line tag-start-line))) + (cond + ;; Analyze bounds if there are any + ((progn + (while (and (not tag-end-pos) + (setq last-pos (re-search-forward js2--jsx-end-tag-re nil t))) + (while (forward-comment 1)) + (when (looking-at js2--jsx-after-tag-re) + (setq tag-end-pos last-pos))) + tag-end-pos) + (setq tag-end-line (line-number-at-pos tag-end-pos) + after-tag-line (line-number-at-pos after-tag-line)) + (or (and + ;; Ensure we're actually within the bounds of the jsx + (<= current-line tag-end-line) + ;; An "after" line which does not end an element begins with + ;; js, so indent it like js + (<= current-line after-tag-line)) + (and + ;; Handle another case where there could be e.g. comments after + ;; the element + (> current-line tag-end-line) + (< current-line after-tag-line) + (setq type 'after)))) + ;; They may not be any bounds (yet) + (t)) + ;; Check if we're inside an embedded multi-line js expression + (cond + ((not type) + (goto-char current-pos) + (end-of-line) + (setq parens (nth 9 (syntax-ppss))) + (while (and parens (not type)) + (setq paren (car parens)) + (cond + ((and (>= paren tag-start-pos) + ;; Curly bracket indicates the start of an embedded expression + (= (char-after paren) 123) ; { + ;; The first line of the expression is indented like sgml + (> current-line (line-number-at-pos paren)) + ;; Check if within a closing curly bracket (if any) + ;; (exclusive, as the closing bracket is indented like sgml) + (cond + ((progn + (goto-char paren) + (ignore-errors (let (forward-sexp-function) + (forward-sexp)))) + (< current-line (line-number-at-pos))) + (t))) + ;; Indicate this guy will be indented specially + (setq type 'expression)) + (t (setq parens (cdr parens))))) + t) + (t)) + (cond + (type) + ;; Indent the first jsx thing like js so we can indent future jsx things + ;; like sgml relative to the first thing + ((= current-line tag-start-line) 'first) + ('nth)))))) + +(defmacro js2--as-sgml (&rest body) + "Execute BODY as if in sgml-mode." + `(with-syntax-table sgml-mode-syntax-table + (let (forward-sexp-function + parse-sexp-lookup-properties) + ,@body))) + +(defun js2--expression-in-sgml-indent-line () + "Indent the current line as JavaScript or SGML (whichever is farther)." + (let* (indent-col + (savep (point)) + ;; Don't whine about errors/warnings when we're indenting. + ;; This has to be set before calling parse-partial-sexp below. + (inhibit-point-motion-hooks t) + (parse-status (save-excursion + (syntax-ppss (point-at-bol))))) + ;; Don't touch multiline strings. + (unless (nth 3 parse-status) + (setq indent-col (save-excursion + (back-to-indentation) + (if (>= (point) savep) (setq savep nil)) + (js2--as-sgml (sgml-calculate-indent)))) + (if (null indent-col) + 'noindent + ;; Use whichever indentation column is greater, such that the sgml + ;; column is effectively a minimum + (setq indent-col (max (js2-proper-indentation parse-status) + (+ indent-col js2-basic-offset))) + (if savep + (save-excursion (indent-line-to indent-col)) + (indent-line-to indent-col)))))) + +(defun js2-jsx-indent-line () + "Indent the current line as JSX (with SGML offsets). +i.e., customize JSX element indentation with `sgml-basic-offset' +et al." + (interactive) + (let ((indentation-type (js2--jsx-indented-element-p))) + (cond + ((eq indentation-type 'expression) + (js2--expression-in-sgml-indent-line)) + ((or (eq indentation-type 'first) + (eq indentation-type 'after)) + ;; Don't treat this first thing as a continued expression (often a "<" or + ;; ">" causes this misinterpretation) + (cl-letf (((symbol-function #'js2-continued-expression-p) 'ignore)) + (js2-indent-line))) + ((eq indentation-type 'nth) + (js2--as-sgml (sgml-indent-line))) + (t (js2-indent-line))))) + +(provide 'js2-old-indent) + +;;; js2-old-indent.el ends here
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/tests/consume.el @@ -0,0 +1,84 @@ +;;; tests/consume.el --- Some tests for js2-mode. + +;; Copyright (C) 2016 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Code: + +(require 'ert) +(require 'ert-x) +(require 'js2-mode) + +(defun js2-mode--and-parse () + (js2-mode) + (js2-reparse)) + +;;; Comments + +(ert-deftest js2-comments-between () + (with-temp-buffer + (insert "0\n//\n[0,/* */1]") + (js2-mode--and-parse) + (let ((comments-list (js2-ast-root-comments js2-mode-ast)) + comments) + (setq comments (js2-comments-between 1 2 comments-list)) + (should (null comments)) + ;; comment head between region + (setq comments (js2-comments-between 1 3 comments-list)) + (should (= (length comments) 1)) + ;; comment body between region + (setq comments (js2-comments-between 4 5 comments-list)) + (should (= (length comments) 1)) + ;; comment tail between region + (setq comments (js2-comments-between 5 6 comments-list)) + (should (= (length comments) 1)) + (setq comments (js2-comments-between 6 6 comments-list)) + (should (null comments)) + (setq comments (js2-comments-between 10 12 comments-list)) + (should (= (length comments) 1)) + ;; multiple comments between + (setq comments (js2-comments-between 5 15 comments-list)) + (should (= (length comments) 2)) + ;; pass comments-list when no AST available + (setq js2-mode-ast nil) + (setq comments (js2-comments-between 8 9 comments)) + (should (= (length comments) 1)) + ))) + +;;; Visitors + +(ert-deftest js2-visit-import-clause-in-order () + (with-temp-buffer + (insert "import defaultImport, { a, b, c} from 'xyz';") + (js2-mode--and-parse) + (let (visit-log) + (js2-visit-ast js2-mode-ast (lambda (node end-p) + (when (and (not end-p) (js2-name-node-p node)) + (let* ((start (js2-node-abs-pos node)) + (end (+ start (js2-node-len node)))) + (push (buffer-substring-no-properties start end) visit-log))) + t)) + (setq visit-log (nreverse visit-log)) + (should (equal visit-log (list "defaultImport" "a" "b" "c")))))) + +(ert-deftest js2-node-parent-stmt/arrow-function () + (ert-with-test-buffer (:name 'js2-node-parent-stmt/arrow-function) + (insert "expect(() => ") + (save-excursion (insert "func(undefined)).toThrow(/undefined/);")) + (js2-mode--and-parse) + (let ((parent-stmt (js2-node-parent-stmt (js2-node-at-point)))) + (should (= (js2-node-abs-pos parent-stmt) 1)))))
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/tests/externs.el @@ -0,0 +1,126 @@ +;;; tests/externs.el --- Some tests for js2-mode. + +;; Copyright (C) 2009, 2011-2014, 2016 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Code: + +(require 'ert) +(require 'js2-mode) + +(ert-deftest js2-finds-jslint-globals () + (with-temp-buffer + (insert "/*global foo, bar:false, baz: true */") + (js2-mode) + (should (equal (js2-get-jslint-globals) + '("foo" "bar" "baz"))))) + +(ert-deftest js2-no-jslint-globals-without-keyword () + (with-temp-buffer + (insert "/* foo, bar:false, baz: true */") + (js2-mode) + (should (null (js2-get-jslint-globals))))) + +(ert-deftest js2-finds-jslint-globals-in-other-comments () + (with-temp-buffer + (insert "/* foo, bar */\n\n\n/*global quux, tee: true, $*/") + (js2-mode) + (should (equal (js2-get-jslint-globals) + '("quux" "tee" "$"))))) + +(ert-deftest js2-finds-jslint-globals-with-space () + (with-temp-buffer + (insert "/* global foo, bar:false, baz:true") + (js2-mode) + (should (equal (js2-get-jslint-globals) + '("foo" "bar" "baz"))))) + +(ert-deftest js2-finds-jslint-globals-with-newline () + (with-temp-buffer + (insert "/* global\nfoo, bar") + (js2-mode) + (should (equal (js2-get-jslint-globals) + '("foo" "bar"))))) + +;;;TODO +;; ensure that any symbols bound with the import syntax are added to the extern list +;; ensure that any symbols bound with the export syntax exist in the file scope + +;; Test `/*jslint*/` declarations + +(ert-deftest js2-finds-jslint-declaration-externs () + (with-temp-buffer + (insert "/*jslint browser: true, node: true*/") + (js2-mode) + (let ((found-externs (js2-get-jslint-declaration-externs))) + (should (and (member "navigator" found-externs) + (member "__filename" found-externs)))))) + +(ert-deftest js2-finds-jslint-declaration-externs-without-property-value () + (with-temp-buffer + (insert "/*jslint devel, es6: true, couch") + (js2-mode) + (let ((found-externs (js2-get-jslint-declaration-externs))) + (should (and (member "prompt" found-externs) + (member "Promise" found-externs) + (member "require" found-externs)))))) + +(ert-deftest js2-no-jslint-declaration-externs-without-keyword () + (with-temp-buffer + (insert "/* browser: true, node: true*/") + (js2-mode) + (should (null (js2-get-jslint-declaration-externs))))) + +(ert-deftest js2-no-jslint-declaration-externs-for-nonexistent-env () + (with-temp-buffer + (insert "/*jslint nonexistent: true*/") + (js2-mode) + (should (null (js2-get-jslint-declaration-externs))))) + +(ert-deftest js2-finding-jslint-declaration-externs-ignores-nonexistent () + (with-temp-buffer + (insert "/*jslint es6: true, nonexistent: true, couch: true*/") + (js2-mode) + (let ((found-externs (js2-get-jslint-declaration-externs))) + (should (and (member "Map" found-externs) + (member "emit" found-externs)))))) + +(ert-deftest js2-finds-jslint-declaration-externs-in-other-comments () + (with-temp-buffer + (insert "/* foo, bar */\n\n\n/*jslint devel: true, node: true*/") + (js2-mode) + (let ((found-externs (js2-get-jslint-declaration-externs))) + (should (and (member "Debug" found-externs) + (member "exports" found-externs)))))) + +(ert-deftest js2-finds-jslint-declaration-externs-with-space () + (with-temp-buffer + (insert "/* jslint browser: true, couch:true,es6 :true */") + (js2-mode) + (let ((found-externs (js2-get-jslint-declaration-externs))) + (should (and (member "document" found-externs) + (member "getRow" found-externs) + (member "Proxy" found-externs)))))) + +(ert-deftest js2-finds-jslint-globals-with-newline () + (with-temp-buffer + (insert "/*jslint\nbrowser: true,\nnode:\ntrue\n, devel:\ntrue\n*/") + (js2-mode) + (let ((found-externs (js2-get-jslint-declaration-externs))) + (should (and (member "history" found-externs) + (member "Buffer" found-externs) + (member "alert" found-externs))))))
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/tests/indent.el @@ -0,0 +1,291 @@ +;;; tests/indent.el --- Some tests for js2-mode. + +;; Copyright (C) 2009, 2011-2016 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Code: + +(require 'ert) +(require 'js2-mode) +(require 'cl-lib) +(require 'js2-old-indent) + +(defun js2-test-indent (content keep-indent) + (let ((s (replace-regexp-in-string "^ *|" "" content))) + (with-temp-buffer + (insert + (if keep-indent + s + (replace-regexp-in-string "^ *" "" s))) + (js2-jsx-mode) + (js2-reparse) ; solely for js2-jsx-self-closing, for some reason + (indent-region (point-min) (point-max)) + (should (string= s (buffer-substring-no-properties + (point-min) (point))))))) + +(cl-defmacro js2-deftest-indent (name content &key bind keep-indent) + `(ert-deftest ,(intern (format "js2-%s" name)) () + (let ,(append '(indent-tabs-mode + (js2-basic-offset 2) + (js2-pretty-multiline-declarations t) + (inhibit-point-motion-hooks t)) + bind) + (js2-test-indent ,content ,keep-indent)))) + +(put 'js2-deftest-indent 'lisp-indent-function 'defun) + +(js2-deftest-indent no-multiline-decl-indent-after-semicolon + "var foo = 1; + |bar = 2") + +(js2-deftest-indent multiline-decl-indent-after-comma + "let foo = 1, + | bar = 2") + +(js2-deftest-indent no-multiline-decl-when-disabled + "let foo = 1, + |bar = 2" + :bind ((js2-pretty-multiline-declarations nil))) + +(js2-deftest-indent multiline-decl-with-continued-expr + "var foo = 100500 + | + 1") + +(js2-deftest-indent multiline-decl-with-continued-expr-same-line + "var foo = 100500 / + | 16;") + +(js2-deftest-indent no-multiline-decl-with-operator-inside-string + "var foo = bar('/protocols/') + |baz()") + +(js2-deftest-indent no-multiline-decl-implicit-semicolon + "var foo = 100500 + |1") + +(js2-deftest-indent multiline-decl-sees-keyword-width + "const foo = 1, + | bar = 2;") + +(js2-deftest-indent multiline-decl-second-arg-value-parenthesised + "var foo = 1, + | bar = [ + | 1, 2, + | 3, 4 + | ], + | baz = 5;") + +(js2-deftest-indent multiline-decl-first-arg-function-normal + "var foo = function() { + | return 7; + |}, + | bar = 8;") + +(js2-deftest-indent multiline-decl-first-arg-function-indent-all + "var foo = function() { + | return 7; + | }, + | bar = 8;" + :bind ((js2-pretty-multiline-declarations 'all))) + +(js2-deftest-indent default-keyword-as-property + "var foo = { + | case: 'zzzz', + | default: 'donkey', + | tee: 'ornery' + |};") + +(js2-deftest-indent multiline-string-noop + "`multiline string + | contents + | are kept + | unchanged!`" + :keep-indent t) + +(js2-deftest-indent no-multiline-decl-first-arg-function-dynamic + "var foo = function() { + | return 7; + |};" + :bind ((js2-pretty-multiline-declarations 'dynamic))) + +(js2-deftest-indent multiline-decl-first-arg-function-indent-dynamic + "var foo = function() { + | return 7; + | }, + | bar = 8;" + :bind ((js2-pretty-multiline-declarations 'dynamic))) + +(js2-deftest-indent multiline-decl-first-arg-function-indent-dynamic-comment + "var foo = function() { + | return 7; + | }/* MUAHAHAHA, ah ha! */, + | bar = 8;" + :bind ((js2-pretty-multiline-declarations 'dynamic))) + +(js2-deftest-indent multiline-decl-first-arg-function-indent-dynamic-scan-error + "var foo = function() { + | return 7; + | , + | bar = 8;" + :bind ((js2-pretty-multiline-declarations 'dynamic))) + +(js2-deftest-indent indent-generator-method + "class A { + | * x() { + | return 1 + | * a(2); + | } + |}") + +(js2-deftest-indent indent-generator-computed-method + "class A { + | *[Symbol.iterator]() { + | yield 'Foo'; + | yield 'Bar'; + | } + |}") + +(js2-deftest-indent case-inside-switch + "switch(true) { + |case 'true': + | return 1; + |}") + +(js2-deftest-indent case-inside-switch-with-extra-indent + "switch(true) { + | case 'true': + | return 1; + |}" + :bind ((js2-indent-switch-body t))) + +(js2-deftest-indent case-inside-switch-with-extra-indent-curly-after-newline + "switch(true) + |{ + | case 'true': + | return 1; + |}" + :bind ((js2-indent-switch-body t))) + +(js2-deftest-indent continued-expression-vs-unary-minus + "var arr = [ + | -1, 2, + | -3, 4 + + | -5 + |];") + +(js2-deftest-indent spread-inside-array + "var z = [ + | ...iterableObj, + | 4, + | 5 + |]") + +(js2-deftest-indent no-continued-expression-after-regexp + "var re = /some value/ + |str.match(re)") + +(js2-deftest-indent jsx-one-line + "var foo = <div></div>;") + +(js2-deftest-indent jsx-children-parentheses + "return ( + | <div> + | </div> + | <div> + | <div></div> + | <div> + | <div></div> + | </div> + | </div> + |);") + +(js2-deftest-indent jsx-children-unclosed + "return ( + | <div> + | <div>") + +(js2-deftest-indent jsx-argument + "React.render( + | <div> + | <div></div> + | </div>, + | { + | a: 1 + | }, + | <div> + | <div></div> + | </div> + |);") + +(js2-deftest-indent jsx-leading-comment + "return ( + | // Sneaky! + | <div></div> + |);") + +(js2-deftest-indent jsx-trailing-comment + "return ( + | <div></div> + | // Sneaky! + |);") + +(js2-deftest-indent jsx-self-closing + ;; This ensures we know the bounds of a self-closing element + "React.render( + | <input + | />, + | { + | a: 1 + | } + |);" + :bind ((sgml-attribute-offset 1))) ; Emacs 24.5 -> 25 compat + +(js2-deftest-indent jsx-embedded-js-content + "return ( + | <div> + | {array.map(function () { + | return { + | a: 1 + | }; + | })} + | </div> + |);") + +(js2-deftest-indent jsx-embedded-js-unclosed + "return ( + | <div> + | {array.map(function () { + | return { + | a: 1") + +(js2-deftest-indent jsx-embedded-js-attribute + "return ( + | <div attribute={array.map(function () { + | return { + | a: 1 + | }; + | + | return { + | a: 1 + | }; + | + | return { + | a: 1 + | }; + | })}> + | </div> + |);")
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/tests/jsdoc.el @@ -0,0 +1,113 @@ +;;; tests/jsdoc.el --- Tests for js2-mode highlighting of jsdoc comments. + +;; Copyright (C) 2009, 2011-2017 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Code: + +(require 'ert) +(require 'ert-x) +(require 'js2-mode) + +(defun js2-get-font-lock-face-props (beg end) + "Return a list of three-tuples (START END FONT-LOCK-FACE). +BEG and END are the current buffer boundaries to use." + (unless (get-char-property beg 'font-lock-face) + (setq beg (next-single-char-property-change beg 'font-lock-face nil end))) + (let (fontification change) + (while (< beg end) + (setq change (next-single-char-property-change beg 'font-lock-face nil end)) + (push (list beg change (get-char-property beg 'font-lock-face)) fontification) + (setq beg (if (get-char-property change 'font-lock-face) + change + (next-single-char-property-change change 'font-lock-face nil end)))) + (nreverse fontification))) + +(defmacro js2-jsdoc-deftest (name comment-text fontification) + (declare (indent defun)) + (let ((test-name (intern (format "js2-jsdoc-%s" name)))) + `(ert-deftest ,test-name () + (ert-with-test-buffer (:name ',test-name) + (insert ,comment-text) + (js2-mode) + (js2-reparse) + (should (equal (js2-get-font-lock-face-props (point-min) (point-max)) + ,fontification)))))) + +(js2-jsdoc-deftest param + "/**\n * @prop {string} p - The property\n */\n" + '((1 8 font-lock-doc-face) + (8 13 js2-jsdoc-tag) + (13 15 font-lock-doc-face) + (15 21 js2-jsdoc-type) + (21 23 font-lock-doc-face) + (23 24 js2-jsdoc-value) + (24 43 font-lock-doc-face))) + +(js2-jsdoc-deftest typed + "/**\n * @implements {Interface}\n */\n" + '((1 8 font-lock-doc-face) + (8 19 js2-jsdoc-tag) + (19 21 font-lock-doc-face) + (21 30 js2-jsdoc-type) + (30 35 font-lock-doc-face))) + +(js2-jsdoc-deftest arg + "/**\n * @name TheName \n */\n" + '((1 8 font-lock-doc-face) + (8 13 js2-jsdoc-tag) + (13 14 font-lock-doc-face) + (14 21 js2-jsdoc-value) + (21 26 font-lock-doc-face))) + +(js2-jsdoc-deftest empty + "/**\n * @class \n */\n" + '((1 8 font-lock-doc-face) + (8 14 js2-jsdoc-tag) + (14 19 font-lock-doc-face))) + +(js2-jsdoc-deftest param-same-line + "/** @prop {string} p - The property */\n" + '((1 5 font-lock-doc-face) + (5 10 js2-jsdoc-tag) + (10 12 font-lock-doc-face) + (12 18 js2-jsdoc-type) + (18 20 font-lock-doc-face) + (20 21 js2-jsdoc-value) + (21 39 font-lock-doc-face))) + +(js2-jsdoc-deftest typed-same-line + "/** @implements {Interface} */\n" + '((1 5 font-lock-doc-face) + (5 16 js2-jsdoc-tag) + (16 18 font-lock-doc-face) + (18 27 js2-jsdoc-type) + (27 31 font-lock-doc-face))) + +(js2-jsdoc-deftest arg-same-line + "/** @name TheName */\n" + '((1 5 font-lock-doc-face) + (5 10 js2-jsdoc-tag) + (10 11 font-lock-doc-face) + (11 18 js2-jsdoc-value) + (18 21 font-lock-doc-face))) + +(js2-jsdoc-deftest empty-same-line + "/** @class */\n" + '((1 5 font-lock-doc-face) + (5 11 js2-jsdoc-tag) + (11 14 font-lock-doc-face)))
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/tests/json-path.el @@ -0,0 +1,64 @@ +;;; tests/json-path.el --- Test of using js2-mode AST to print JSON path. + +;; Copyright (C) 2015 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Code: + +(require 'ert) +(require 'js2-mode) + +(ert-deftest js2-json-path-with-actual-array-index () + (with-temp-buffer + (insert "var a = { hello: [1, 2, [1,3,3,4, { world: { hell: { yes: [1,2, 'test'] } } }]] };") + (js2-mode) + (goto-char 0) + (search-forward "test") + (should (string= (js2-print-json-path) "hello[2][4].world.hell.yes[2]")))) + +(ert-deftest js2-json-path-pure-arrays () + (with-temp-buffer + (insert "var a = [5, 1, 4, [ 4, [1, 2, [1, 3.9, 4, [1, 2, 'test',3]]]], 9, 9];") + (js2-mode) + (goto-char 0) + (search-forward "test") + (should (string= (js2-print-json-path) "[3][1][2][3][2]")))) + +(ert-deftest js2-json-path-key-is-numeric () + (with-temp-buffer + (insert "var b = {hello: {3 : {world: {2: 'test'}}}};") + (js2-mode) + (goto-char 0) + (search-forward "test") + (should (string= (js2-print-json-path) "hello.3.world.2")))) + +(ert-deftest js2-json-path-not-found () + (with-temp-buffer + (insert "console.log('test');") + (js2-mode) + (goto-char 0) + (search-forward "test") + (should (eq (js2-print-json-path) nil)))) + +(ert-deftest js2-json-path-with-array-index-hardcoded () + (with-temp-buffer + (insert "var a = { hello: [1, 2, [1,3,3,4, { world: { hell: { yes: [1,2, 'test'] } } }]] };") + (js2-mode) + (goto-char 0) + (search-forward "test") + (should (string= (js2-print-json-path 1) "hello[1][1].world.hell.yes[1]")) + (should (string= (js2-print-json-path 0) "hello[0][0].world.hell.yes[0]"))))
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/tests/navigation.el @@ -0,0 +1,110 @@ +;;; tests/navigation.el --- Some tests for js2-mode. + +;; Copyright (C) 2009, 2011-2015 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Code: + +(require 'ert) +(require 'js2-mode) + +(cl-defun js2-navigation-helper (buffer-content &optional expected-point (point-offset 1) expected-error-msg) + (with-temp-buffer + (insert buffer-content) + (let ((start-point (or (- (point) point-offset))) + actual-error-msg) + (js2-mode) + (goto-char start-point) + (if expected-error-msg + (setq actual-error-msg + (cadr (should-error (js2-jump-to-definition) :type 'error))) + (js2-jump-to-definition)) + (print (format "%d %d" (point) start-point)) + (should (= (point) (or expected-point start-point))) + (should (string= actual-error-msg expected-error-msg))))) + +(ert-deftest js2-jump-to-var () + (js2-navigation-helper "var soup = 2; soup" 5)) + +(ert-deftest js2-jump-to-function () + (js2-navigation-helper "function aFunction() {}; aFunction" 1)) + +(ert-deftest js2-jump-to-function-parameters () + (js2-navigation-helper "var p1 = 4; function aFunction(p1, p2) {p1};" 32 4)) + +(ert-deftest js2-jump-to-object-property () + (js2-navigation-helper "var aObject = {prop1: 3, prop2: \"hello\"}; aObject.prop1" 16)) + +(ert-deftest js2-no-jump-to-object-property () + (js2-navigation-helper "var aObject = {prop1: 3, prop2: \"hello\"}; anotherObject.prop1" + 61 1 "No jump location found")) + +(ert-deftest js2-jump-to-nested-property () + (js2-navigation-helper "var aObject = {prop1: {prop2: { prop3: 4}}}; aObject.prop1.prop2.prop3" 33)) + +(ert-deftest js2-jump-to-object () + (js2-navigation-helper "var aObject = {prop1: 3, prop2: \"hello\"}; aObject.prop1" 5 13)) + +(ert-deftest js2-jump-to-property () + (js2-navigation-helper "aObject.func = functon(){};aObject.func" 9)) + +(ert-deftest js2-jump-to-property-object-property () + (js2-navigation-helper "aObject.value = {prop:1};aObject.value.prop" 18)) + +(ert-deftest js2-jump-to-function-definition-inside-object-value () + (js2-navigation-helper + "function aFunction(p1, p2) {return p1+p2}; module.exports = {aFunction:aFunction};" 1 6)) + +(ert-deftest js2-no-jump-to-function-definition-object-property () + (js2-navigation-helper + "function aFunction(p1, p2) {return p1+p2}; module.exports = {aFunction:aFunction};" + 67 16 "Node is not a supported jump node")) + +(ert-deftest js2-jump-to-function-inside-property-value-syntax () + (js2-navigation-helper "function aFunction(p1, p2) {return p1+p2}; module.exports = {aFunction};" 1 6)) + + +;; forward-sexp + +(defun js2-test-forward-sexp (pre-point skipped after-sexp) + "Test `js2-mode-forward-sexp'. +The test buffer's contents are set to the concatenation of +PRE-POINT, SKIPPED, and AFTER-SEXP. Point is placed after +PRE-POINT, and `forward-sexp' is called. Then point should be +after SKIPPED." + (with-temp-buffer + (insert pre-point skipped after-sexp) + (js2-mode) + (goto-char (1+ (length pre-point))) + (forward-sexp) + (should (= (point) (+ 1 (length pre-point) (length skipped)))))) + +(ert-deftest js2-forward-sexp-skip-semi () + "Ensure expr-stmt-nodes' semicolons are skipped over." + (js2-test-forward-sexp "" "const s = 123;" "")) + +(ert-deftest js2-forward-sexp-inside-string () + "Test forward sexp inside a string." + (js2-test-forward-sexp "const s = 'some " "(string contents)" " xyz';")) + +(ert-deftest js2-backward-sexp-inside-string () + "Test backward sexp inside a string." + (with-temp-buffer + (insert "const s = 'some (string contents) ") + (save-excursion (insert "xyz';")) + (backward-sexp) + (should (= (point) 17))))
new file mode 100644 --- /dev/null +++ b/elpa/js2-mode-20190219/tests/parser.el @@ -0,0 +1,1429 @@ +;;; tests/parser.el --- Some tests for js2-mode. + +;; Copyright (C) 2009, 2011-2017 Free Software Foundation, Inc. + +;; This file is part of GNU Emacs. + +;; GNU Emacs 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. + +;; GNU Emacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>. + +;;; Code: + +(require 'ert) +(require 'ert-x) +(require 'js2-mode) +(require 'cl-lib) + +(defmacro js2-deftest (name buffer-contents &rest body) + (declare (indent defun)) + `(ert-deftest ,(intern (format "js2-%s" name)) () + (with-temp-buffer + (save-excursion + (insert ,buffer-contents)) + (unwind-protect + (progn + ,@body) + (fundamental-mode))))) + +(defun js2-mode--and-parse () + (js2-mode) + (js2-reparse)) + +(defun js2-test-string-to-ast (s) + (insert s) + (js2-mode--and-parse) + (should (null js2-mode-buffer-dirty-p)) + js2-mode-ast) + +(cl-defun js2-test-parse-string (code-string &key syntax-error errors-count + reference warnings-count) + (ert-with-test-buffer (:name 'origin) + (let ((ast (js2-test-string-to-ast code-string))) + (if syntax-error + (let ((errors (js2-ast-root-errors ast))) + (should (= (or errors-count 1) (length errors))) + (cl-destructuring-bind (_ pos len) (car (last errors)) + (should (string= syntax-error (substring code-string + (1- pos) (+ pos len -1)))))) + (should (= 0 (length (js2-ast-root-errors ast)))) + (ert-with-test-buffer (:name 'copy) + (js2-print-tree ast) + (skip-chars-backward " \t\n") + (should (string= (or reference code-string) + (buffer-substring-no-properties + (point-min) (point))))) + (when warnings-count + (should (= warnings-count + (length (js2-ast-root-warnings ast))))))))) + +(cl-defmacro js2-deftest-parse (name code-string &key bind syntax-error errors-count + reference warnings-count) + "Parse CODE-STRING. If SYNTAX-ERROR is nil, print syntax tree +with `js2-print-tree' and assert the result to be equal to +REFERENCE, if present, or the original string. If SYNTAX-ERROR +is passed, expect syntax error highlighting substring equal to +SYNTAX-ERROR value. BIND defines bindings to apply them around +the test." + (declare (indent defun)) + `(ert-deftest ,(intern (format "js2-%s" name)) () + (let ,(append bind '((js2-basic-offset 2))) + (js2-test-parse-string ,code-string + :syntax-error ,syntax-error + :errors-count ,errors-count + :warnings-count ,warnings-count + :reference ,reference)))) + +(defun js2-find-node (node predicate) + "Find the first descendant of NODE meeting PREDICATE." + (let (target) + (js2-visit-ast node (lambda (n end-p) + (unless end-p + (if (funcall predicate n) + (progn (setq target n) nil) + t)))) + target)) + +(defun js2-node-text (node) + "Return the part of the buffer corresponding to NODE as a string." + (let ((beg (js2-node-abs-pos node))) + (buffer-substring-no-properties beg (+ beg (js2-node-len node))))) + +;;; Basics + +(js2-deftest-parse variable-assignment + "a = 1;") + +(js2-deftest-parse empty-object-literal + "b = {};") + +(js2-deftest-parse empty-array-literal + "c = [];") + +(js2-deftest-parse array-with-missing-elements + "var a = [1, 2, ,];") + +(js2-deftest-parse comma-after-regexp + "d = /eee/, 42;") + +(js2-deftest-parse return-statement + "function foo() {\n return 2;\n}") + +(js2-deftest-parse function-statement + "function foo() {\n}") + +(js2-deftest-parse trailing-comma-in-function-arguments + "f(a, b,);" + :reference "f(a, b);") + +(js2-deftest-parse function-statement-inside-block + "if (true) {\n function foo() {\n }\n}") + +(js2-deftest-parse function-expression-statements-are-verboten + "function() {}" :syntax-error "(") + +(js2-deftest-parse member-expr-as-function-name + "function a.b.c[2](x, y) {\n}" + :bind ((js2-allow-member-expr-as-function-name t))) + +(js2-deftest-parse named-function-expression + "a = function b() {};") + +(js2-deftest-parse parenthesized-expression + "(1 + 2);") + +(js2-deftest-parse for-with-in-operator-in-parens + "for (var y = (0 in []) in {}) {\n}") + +(js2-deftest-parse for-with-in-operator-in-cond + "for (var y = 1 ? 0 in [] : false in {}) {\n}") + +(js2-deftest-parse let-expression + "(let (x = 42) x);") + +(js2-deftest-parse let-expression-statement + "let (x = 42) x;") + +(js2-deftest-parse void + "void 0;") + +;;; Callers of `js2-valid-prop-name-token' + +(js2-deftest-parse parse-property-access-when-not-keyword + "A.foo = 3;") + +(js2-deftest-parse parse-property-access-when-keyword + "A.in = 3;" + :bind ((js2-allow-keywords-as-property-names t))) + +(js2-deftest-parse parse-property-access-when-keyword-no-xml + "A.in = 3;" + :bind ((js2-allow-keywords-as-property-names t) + (js2-compiler-xml-available nil))) + +(js2-deftest-parse parse-object-literal-when-not-keyword + "a = {b: 1};") + +(js2-deftest-parse parse-object-literal-when-keyword + "a = {in: 1};" + :bind ((js2-allow-keywords-as-property-names t))) + +;;; 'of' contextual keyword + +(js2-deftest-parse parse-legacy-array-comp-loop-with-of + "[a for (a of [])];") + +(js2-deftest-parse parse-array-comp-loop + "[for (a of []) a];") + +(js2-deftest-parse parse-for-of + "for (var a of []) {\n}") + +(js2-deftest-parse of-can-be-name + "void of;") + +(js2-deftest-parse of-can-be-object-name + "of.z;") + +(js2-deftest-parse of-can-be-var-name + "var of = 3;") + +(js2-deftest-parse of-can-be-function-name + "function of() {\n}") + +;;; Destructuring binding + +(js2-deftest-parse destruct-in-declaration + "var {a, b} = {a: 1, b: 2};" + :warnings-count 0) + +(js2-deftest-parse destruct-in-arguments + "function f({a: aa, b: bb}) {\n}" + :warnings-count 0) + +(js2-deftest-parse destruct-in-array-comp-loop + "[a + b for ([a, b] in [[0, 1], [1, 2]])];") + +(js2-deftest-parse destruct-in-catch-clause + "try {\n} catch ({a, b}) {\n a + b;\n}" + :warnings-count 0) + +(js2-deftest-parse destruct-with-initializer-in-object + "var {a, b = 2, c} = {};\nb;" + :warnings-count 0) + +(js2-deftest-parse destruct-with-initializer-in-array + "var [a, b = 2, c] = [];\nb;" + :warnings-count 0) + +(js2-deftest-parse destruct-non-name-target-is-error + "var {1=1} = {};" :syntax-error "1" :errors-count 1) + +(js2-deftest-parse destruct-with-initializer-in-function-params + "function f({a, b = 1, c}, [d, e = 1, f]) {\n}") + +(js2-deftest-parse destruct-with-default-in-function-params + "function f({x = 1, y = 2} = {}, [x, y] = [1, 2]) {\n}") + +(js2-deftest-parse destruct-name-conflict-is-error-in-object + "\"use strict\";\nvar {a=1,a=2} = {};" :syntax-error "a" :errors-count 1) + +(js2-deftest destruct-name-conflict-is-warning-in-array "\"use strict\";\nvar [a=1,a=2] = [];" + (js2-mode--and-parse) + (should (equal '("msg.var.redecl" "a") + (caar js2-parsed-warnings)))) + +(js2-deftest initializer-outside-destruct-is-error "({a=1});" + (js2-mode--and-parse) + (should (equal "msg.init.no.destruct" + (car (caar js2-parsed-errors))))) + +;;; Object literals + +(js2-deftest-parse object-literal-shorthand + "var x = {a: 1, b, c: 1, d};") + +(js2-deftest-parse object-literal-shorthard-with-number + "var a = {1};" :syntax-error "}" :errors-count 2) + +(js2-deftest-parse object-literal-method + "var x = {f(y) { return y;\n}};") + +(js2-deftest object-literal-method-own-name-in-scope "({f(){f();}});" + (js2-mode--and-parse) + (should (equal '("msg.undeclared.variable" "f") + (caar js2-parsed-warnings)))) + +(js2-deftest-parse object-literal-getter-method + "var x = {get f() { return 42;\n}};") + +(js2-deftest-parse object-literal-setter-method + "var x = {set f(y) { x = y;\n}};") + +(js2-deftest-parse object-literal-computed-keys + "var x = {[Symbol.iterator]: function() {}};") + +(js2-deftest-parse object-literal-computed-function-keys + "var x = {[foo + bar](y) { return y;\n}};") + +(js2-deftest-parse object-literal-computed-getter-key + "var x = {get [foo + bar]() { return 42;\n}};") + +(js2-deftest-parse object-literal-generator + "var x = {*foo() { yield* 42;\n}};") + +(js2-deftest-parse object-literal-computed-generator-key + "var x = {*[foo + bar]() { yield 42;\n}};") + +;;; Function definition + +(js2-deftest function-redeclaring-var "var gen = 3; function gen() {};" + (js2-mode--and-parse) + (should (= (length (js2-ast-root-warnings js2-mode-ast)) 1))) + +(js2-deftest function-expression-var-same-name "var gen = function gen() {};" + (js2-mode--and-parse) + (should (null (js2-ast-root-warnings js2-mode-ast)))) + +;;; Function parameters + +(js2-deftest-parse function-with-default-parameters + "function foo(a = 1, b = a + 1) {\n}") + +(js2-deftest-parse function-with-no-default-after-default + "function foo(a = 1, b) {\n}") + +(js2-deftest-parse function-with-destruct-after-default + "function foo(a = 1, {b, c}) {\n}") + +(js2-deftest-parse function-with-rest-parameter + "function foo(a, b, ...rest) {\n}") + +(js2-deftest-parse function-with-param-after-rest-parameter + "function foo(a, ...b, rest) {\n}" + :syntax-error "rest") + +(js2-deftest-parse function-with-destruct-after-rest-parameter + "function foo(a, ...b, {}) {\n}" + :syntax-error "{}") + +(js2-deftest-parse function-with-rest-after-default-parameter + "function foo(a = 1, ...rest) {\n}") + +(js2-deftest-parse function-with-trailing-comma-in-param-list + "function foo(a, b,) {\n}" + :reference "function foo(a, b) {\n}") + +;;; Strict mode errors + +(js2-deftest-parse function-bad-strict-parameters + "'use strict';\nfunction foo(eval, {arguments}, bar) {\n}" + :syntax-error "eval" :errors-count 2) + +(js2-deftest-parse function-retroactive-bad-strict-parameters + "function foo(arguments) {'use strict';}" + :syntax-error "arguments" :errors-count 1) + +(js2-deftest-parse function-duplicate-strict-parameters + "'use strict';\nfunction foo(a, a) {\n}" + :syntax-error "a" :errors-count 1) + +(js2-deftest-parse function-bad-strict-function-name + "'use strict';\nfunction eval() {\n}" + :syntax-error "eval" :errors-count 1) + +(js2-deftest-parse function-bad-retroactive-strict-function-name + "function arguments() {'use strict';}" + :syntax-error "arguments" :errors-count 1) + +(js2-deftest-parse function-bad-strict-catch-name + "'use strict';\ntry {} catch (eval) {}" + :syntax-error "eval" :errors-count 1) + +(js2-deftest-parse function-bad-strict-variable-name + "'use strict';\nvar eval = 'kekeke';" + :syntax-error "eval" :errors-count 1) + +(js2-deftest-parse function-bad-strict-assignment + "'use strict';\narguments = 'fufufu';" + :syntax-error "arguments" :errors-count 1) + +(js2-deftest-parse function-property-strict-assignment + "'use strict';\narguments.okay = 'alright';") + +(js2-deftest-parse function-strict-with + "'use strict';\nwith ({}) {}" + :syntax-error "with" :errors-count 1) + +(js2-deftest-parse function-strict-octal + "'use strict';\nvar number = 0644;" + :syntax-error "0644" :errors-count 1) + +(js2-deftest-parse function-strict-octal-allow-0o + "'use strict';\n0o644;" :reference "'use strict';\n420;") + +(js2-deftest-parse function-strict-duplicate-keys + "'use strict';\nvar object = {a: 1, a: 2, 'a': 3, ['a']: 4, 1: 5, '1': 6, [1 + 1]: 7};" + :syntax-error "a" :errors-count 4) ; "a" has 3 dupes, "1" has 1 dupe. + +(js2-deftest-parse function-strict-duplicate-getter + "'use strict';\nvar a = {get x() {}, get x() {}};" + :syntax-error "x" :errors-count 1) + +(js2-deftest-parse function-strict-duplicate-setter + "'use strict';\nvar a = {set x() {}, set x() {}};" + :syntax-error "x" :errors-count 1) + +;;; Lack of errors in strict mode + +(js2-deftest-parse function-strict-const-scope + "'use strict';\nconst a;\nif (1) {\n const a;\n}") + +(js2-deftest-parse function-strict-no-getter-setter-duplicate + "'use strict';\nvar a = {get x() {}, set x() {}};") + +;;; Spread operator + +(js2-deftest-parse spread-in-array-literal + "[1, ...[2, 3], 4, ...[5, 6]];") + +(js2-deftest-parse spread-in-function-call + "f(3, ...[t(2), t(3)], 42, ...[t(4)]);") + +(js2-deftest-parse rest-in-array-destructure + "let [x, y, z, ...w] = [1, ...a, ...b, c];") + +(js2-deftest-parse comma-after-rest-in-array + "let [...x,] = [1, 2, 3];" + :syntax-error "," :errors-count 1) + +(js2-deftest-parse elem-after-rest-in-array + "let [...x, y] = [1, 2, 3];" + :syntax-error "," :errors-count 2) + +(js2-deftest-parse array-destructure-expr-default + "let [[x] = [3]] = y;") + +(js2-deftest-parse spread-in-object-literal + "f({x, y, ...z});") + +(js2-deftest-parse rest-in-object-literal + "const {x, y, ...z} = f();") + +;;; Arrow functions + +(js2-deftest-parse arrow-function-with-empty-args-and-no-curlies + "() => false;" :reference "() => {false};") + +(js2-deftest-parse arrow-function-with-args-and-curlies + "(a, b = 1, ...c) => { c;\n};") + +(js2-deftest-parse arrow-function-with-destructuring + "([{a}, b]) => { a + b;\n};") + +(js2-deftest-parse parenless-arrow-function-prohibits-rest + "...b => {b + 1;};" :syntax-error "=>") + +(js2-deftest-parse parenless-arrow-function-prohibits-destructuring + "[a, b] => {a + b;};" :syntax-error "]" :errors-count 4) + +(js2-deftest-parse arrow-function-recovers-from-error + "[(,foo) => 1];" :syntax-error "," :errors-count 6) + +;;; Automatic semicolon insertion + +(js2-deftest-parse no-auto-semi-insertion-after-if + "if (true) {\n}") + +(js2-deftest-parse auto-semi-insertion-after-function + "a = function() {}" :reference "a = function() {};") + +(js2-deftest-parse auto-semi-one-variable-per-line + "x\ny" :reference "x;\ny;") + +;;; Labels + +(js2-deftest-parse labeled-stmt-node + "foo:\nbar:\nx = y + 1;") + +(js2-deftest no-label-node-inside-expr "x = y:" + (let (js2-parse-interruptable-p) + (js2-mode--and-parse)) + (let ((assignment (js2-expr-stmt-node-expr (car (js2-scope-kids js2-mode-ast))))) + (should (js2-name-node-p (js2-assign-node-right assignment))))) + +(js2-deftest-parse label-and-loops "for (; ; ) { + loop: + for (; ; ) { + continue loop; + } +}") + +;;; Generators + +(js2-deftest-parse legacy-generator "function foo() {\n yield 1;\n}") + +(js2-deftest-parse legacy-generator-cannot-return + "function foo() {\n yield 1;\n return 2;\n}" :syntax-error "return 2") + +(js2-deftest-parse harmony-generator "function* bar() {\n yield 2;\n return 3;\n}") + +(js2-deftest-parse harmony-generator-yield-star "(function*(a) { yield* a;\n});") + +(js2-deftest-parse harmony-generator-yield-assign-expr + "(function*() { return {a: yield a, b: yield b, c: yield c};\n});") + +;;; Comprehensions + +(js2-deftest-parse parse-legacy-array-comp-loop-with-filter + "[a for (a in b) if (a == 2)];") + +(js2-deftest-parse parse-array-comp-loop-with-filters + "[for (a in b) if (a == 2) if (b != 10) a];") + +(js2-deftest-parse parse-generator-comp-loop-with-filters + "(for (x of y) if (x != 4) x);") + +(js2-deftest-parse parse-array-comp-with-yield-is-ok + "(function() { return [for (x of []) yield x];\n});") + +(js2-deftest-parse parse-generator-comp-with-yield-is-not-ok + "(function() { return (for (x of []) yield x);\n});" + :syntax-error "yield") + +(js2-deftest-parse parse-generator-comp-with-yield-inside-function-is-ok + "(for (x of []) function*() { yield x;\n});") + +;;; Async + +(js2-deftest-parse async-function-statement + "async function foo() {\n}") + +(js2-deftest-parse async-function-statement-inside-block + "if (true) {\n async function foo() {\n }\n}") + +(js2-deftest-parse async-function-expression-statements-are-verboten + "async function() {}" :syntax-error "(") + +(js2-deftest-parse async-named-function-expression + "a = async function b() {};") + +(js2-deftest-parse async-arrow-function-expression + "a = async (b) => { b;\n};") + +(js2-deftest-parse async-arrow-function-without-parens + "a = async b => 3;" :reference "a = async (b) => {3};") + +(js2-deftest-parse async-method-in-object-literal + "({async f() {}});") + +(js2-deftest-parse async-method-kwname-in-object-literal + "({async delete() {}});") + +(js2-deftest-parse async-method-in-class-body + "class C {\n async foo() {}\n}") + +(js2-deftest-parse static-async-method-in-class-body + "class C {\n static async foo() {}\n}") + +(js2-deftest-parse async-method-allow-await + "({async f() { await x;\n}});") + +;;; Await + +(js2-deftest-parse await-is-ok "async function foo() {\n await bar();\n}") + +(js2-deftest-parse await-inside-assignment-is-ok + "async function foo() {\n var result = await bar();\n}") + +(js2-deftest-parse await-inside-array-is-ok + "async function foo() {\n var results = [await bar(), await baz()];\n}") + +(js2-deftest-parse await-inside-non-async-function-is-not-ok + "function foo() {\n await bar();\n}" + :syntax-error "await") + +(js2-deftest-parse await-inside-non-async-arrow-function-is-not-ok + "a = () => { await bar();\n}" + :syntax-error "await") + +;;; 'async' and 'await' are contextual keywords + +(js2-deftest-parse async-can-be-name + "void async;") + +(js2-deftest-parse async-can-be-object-name + "async.z;") + +(js2-deftest-parse async-can-be-var-name + "var async = 3;") + +(js2-deftest-parse async-can-be-function-name + "function async() {\n}") + +(js2-deftest-parse await-can-be-name + "void await;") + +(js2-deftest-parse await-can-be-object-name + "await.z;") + +(js2-deftest-parse await-can-be-var-name + "var await = 3;") + +(js2-deftest-parse await-can-be-function-name + "function await() {\n}") + +;;; Numbers + +(js2-deftest-parse decimal-starting-with-zero "081;" :reference "81;") + +(js2-deftest-parse huge-hex "0x0123456789abcdefABCDEF;" :reference "-1;") + +(js2-deftest-parse octal-without-o "071;" :reference "57;") + +(js2-deftest-parse hex-number-okay "0x123;" :reference "291;") + +(js2-deftest-parse hex-number-broken "0xz23;" + :syntax-error "0xz" :errors-count 2) + +(js2-deftest-parse binary-number-okay "0b101;" :reference "5;") + +(js2-deftest-parse binary-number-broken "0b210;" + :syntax-error "0b2" :errors-count 2) + +(js2-deftest-parse octal-number-okay "0o765;" :reference "501;") + +(js2-deftest-parse octal-number-broken "0o812;" + :syntax-error "0o8" :errors-count 2) + +;;; Modules + +(js2-deftest parse-export-bindings "{one, two as dos}" + (js2-init-scanner) + (should (js2-match-token js2-LC)) + (let ((imports (js2-parse-export-bindings))) + (should (not (null imports))) + (should (= 2 (length imports))) + (let ((first (nth 0 imports)) + (second (nth 1 imports))) + (should (equal "one" (js2-name-node-name (js2-export-binding-node-extern-name first)))) + (should (equal "two" (js2-name-node-name (js2-export-binding-node-extern-name second)))) + (let ((first-name (js2-export-binding-node-local-name first)) + (second-name (js2-export-binding-node-local-name second))) + (should (equal first (js2-node-parent first-name))) + (should (equal 3 (js2-node-len first-name))) + (should (equal "one" (js2-name-node-name first-name))) + (should (equal second (js2-node-parent second-name))) + (should (equal 3 (js2-node-len second-name))) + (should (equal "dos" (js2-name-node-name second-name))))))) + +(js2-deftest parse-export-binding-as-default "one as default" + (js2-init-scanner) + (let ((binding (js2-maybe-parse-export-binding))) + (should binding) + (should (js2-export-binding-node-p binding)) + (let ((name (js2-export-binding-node-local-name binding))) + (should name) + (should (equal "default" (js2-name-node-name name)))))) + +(js2-deftest parse-namespace-import "* as lib;" + (js2-init-scanner) + (should (js2-match-token js2-MUL)) + (let ((namespace-import (js2-parse-namespace-import))) + (should (not (null namespace-import))) + (should (js2-namespace-import-node-p namespace-import)) + (should (= 1 (js2-node-pos namespace-import))) + (should (equal 8 (js2-node-len namespace-import))) + (let ((name-node (js2-namespace-import-node-name namespace-import))) + (should (equal "lib" (js2-name-node-name name-node))) + (should (= 5 (js2-node-pos name-node)))))) + +(js2-deftest-parse parse-namespace-import-error + "import * lib from 'lib';" + :syntax-error "import" + :errors-count 7) + +(js2-deftest parse-from-clause "from 'foo/bar';" + (js2-init-scanner) + (let ((from (js2-parse-from-clause))) + (should (not (null from))) + (should (= 1 (js2-node-pos from))) + (should (= 14 (js2-node-len from))) + (should (equal "foo/bar" (js2-from-clause-node-module-id from))))) + +(js2-deftest parse-import-module-id-only "import 'src/lib'" + (js2-init-scanner) + (should (js2-match-token js2-IMPORT)) + (let ((import (js2-parse-import))) + (should (not (null import))) + (should (= 1 (js2-node-pos import))) + (should (= 16 (js2-node-len import))) + (should (null (js2-import-node-import import))) + (should (null (js2-import-node-from import))))) + +(js2-deftest parse-imported-default-binding "import theDefault from 'src/lib'" + (js2-push-scope (make-js2-scope :pos 0)) + (js2-init-scanner) + (should (js2-match-token js2-IMPORT)) + (let ((import-node (js2-parse-import))) + (should (not (null import-node))) + (should (equal "src/lib" (js2-import-node-module-id import-node))) + (let ((import (js2-import-node-import import-node))) + (should (not (null import))) + (should (null (js2-import-clause-node-namespace-import import))) + (should (null (js2-import-clause-node-named-imports import))) + (let ((default (js2-import-clause-node-default-binding import))) + (should (not (null default))) + (should (js2-export-binding-node-p default)) + (should (equal "theDefault" (js2-name-node-name (js2-export-binding-node-extern-name default))))))) + (should (js2-scope-get-symbol js2-current-scope "theDefault"))) + +(js2-deftest parse-import-namespace-binding "import * as lib from 'src/lib'" + (js2-push-scope (make-js2-scope :pos 0)) + (js2-init-scanner) + (should (js2-match-token js2-IMPORT)) + (let ((import-node (js2-parse-import))) + (should (not (null import-node))) + (should (equal "src/lib" (js2-import-node-module-id import-node))) + (let ((import (js2-import-node-import import-node))) + (should (not (null import))) + (should (null (js2-import-clause-node-default-binding import))) + (should (null (js2-import-clause-node-named-imports import))) + (let ((ns-import (js2-import-clause-node-namespace-import import))) + (should (not (null ns-import))) + (should (js2-namespace-import-node-p ns-import)) + (should (equal "lib" (js2-name-node-name (js2-namespace-import-node-name ns-import))))))) + (should (js2-scope-get-symbol js2-current-scope "lib"))) + +(js2-deftest parse-import-named-imports "import {foo as bar, baz} from 'src/lib'" + (js2-push-scope (make-js2-scope :pos 0)) + (js2-init-scanner) + (should (js2-match-token js2-IMPORT)) + (let ((import-node (js2-parse-import))) + (should (not (null import-node))) + (should (equal "src/lib" (js2-import-node-module-id import-node))) + (let ((import (js2-import-node-import import-node))) + (should (not (null import))) + (should (null (js2-import-clause-node-default-binding import))) + (should (null (js2-import-clause-node-namespace-import import))) + (let ((named-imports (js2-import-clause-node-named-imports import))) + (should (not (null named-imports))) + (should (listp named-imports)) + (should (= 2 (length named-imports))) + (let ((first (nth 0 named-imports)) + (second (nth 1 named-imports))) + (should (equal "bar" (js2-name-node-name (js2-export-binding-node-local-name first)))) + (should (equal "baz" (js2-name-node-name (js2-export-binding-node-local-name second)))))))) + (should (js2-scope-get-symbol js2-current-scope "bar")) + (should (js2-scope-get-symbol js2-current-scope "baz"))) + +(js2-deftest parse-import-default-and-namespace "import stuff, * as lib from 'src/lib'" + (js2-push-scope (make-js2-scope :pos 0)) + (js2-init-scanner) + (should (js2-match-token js2-IMPORT)) + (let ((import-node (js2-parse-import))) + (should (not (null import-node))) + (should (equal "src/lib" (js2-import-node-module-id import-node))) + (let ((import (js2-import-node-import import-node))) + (should (not (null import))) + (should (null (js2-import-clause-node-named-imports import))) + (let ((default (js2-import-clause-node-default-binding import)) + (ns-import (js2-import-clause-node-namespace-import import))) + (should (not (null default))) + (should (equal "stuff" (js2-name-node-name (js2-export-binding-node-local-name default)))) + (should (not (null ns-import))) + (should (js2-namespace-import-node-p ns-import)) + (should (equal "lib" (js2-name-node-name (js2-namespace-import-node-name ns-import))))))) + (should (js2-scope-get-symbol js2-current-scope "stuff")) + (should (js2-scope-get-symbol js2-current-scope "lib"))) + +(js2-deftest parse-import-default-and-named-imports + "import robert as bob, {cookies, pi as PIE} from 'src/lib'" + (js2-push-scope (make-js2-scope :pos 0)) + (js2-init-scanner) + (should (js2-match-token js2-IMPORT)) + (let ((import-node (js2-parse-import))) + (should (not (null import-node))) + (should (equal "src/lib" (js2-import-node-module-id import-node))) + (let ((import (js2-import-node-import import-node))) + (should (not (null import))) + (should (not (null (js2-import-clause-node-named-imports import)))) + (let ((default (js2-import-clause-node-default-binding import)) + (named-imports (js2-import-clause-node-named-imports import))) + (should (not (null default))) + (should (equal "bob" (js2-name-node-name (js2-export-binding-node-local-name default)))) + (should (not (null named-imports))) + (should (= 2 (length named-imports)))))) + (should (js2-scope-get-symbol js2-current-scope "bob")) + (should (js2-scope-get-symbol js2-current-scope "cookies")) + (should (js2-scope-get-symbol js2-current-scope "PIE"))) + +(js2-deftest parse-this-module-in-from-clause "import {url} from this module;" + (js2-push-scope (make-js2-scope :pos 0)) + (js2-init-scanner) + (should (js2-match-token js2-IMPORT)) + (let ((import-node (js2-parse-import))) + (should import-node) + (let ((from-clause (js2-import-node-from import-node))) + (should from-clause) + (should (equal "this" (js2-from-clause-node-module-id from-clause))) + (should (js2-from-clause-node-metadata-p from-clause))))) + +(js2-deftest-parse import-only-for-side-effects "import 'src/lib';") +(js2-deftest-parse import-default-only "import theDefault from 'src/lib';") +(js2-deftest-parse import-named-only "import {one, two} from 'src/lib';") +(js2-deftest-parse import-default-and-named "import theDefault, {one, two} from 'src/lib';") +(js2-deftest-parse import-renaming-default "import * as lib from 'src/mylib';") +(js2-deftest-parse import-renaming-named "import {one as uno, two as dos} from 'src/lib';") +(js2-deftest-parse import-default-and-namespace "import robert as bob, * as lib from 'src/lib';") +(js2-deftest-parse import-from-this-module "import {url} from this module;") + +;; Module Exports + +(js2-deftest export-rexport "export * from 'other/lib'" + (js2-init-scanner) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-export-node-from-clause export-node)))) + +(js2-deftest export-export-named-list "export {foo, bar as bang};" + (js2-init-scanner) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (let ((exports (js2-export-node-exports-list export-node))) + (should exports) + (should (= 2 (length exports)))))) + +(js2-deftest re-export-named-list "export {foo, bar as bang} from 'other/lib'" + (js2-init-scanner) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-export-node-from-clause export-node)) + (let ((exports (js2-export-node-exports-list export-node))) + (should exports) + (should (= 2 (length exports)))))) + +(js2-deftest export-variable-statement "export var foo = 'bar', baz = 'bang';" + (js2-init-scanner) + (js2-push-scope (make-js2-scope :pos 0)) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-export-node-declaration export-node)))) + +(js2-deftest export-const-declaration "export const PI = Math.PI;" + (js2-init-scanner) + (js2-push-scope (make-js2-scope :pos 0)) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-export-node-declaration export-node)))) + +(js2-deftest export-let-declaration "export let foo = [1];" + (js2-init-scanner) + (js2-push-scope (make-js2-scope :pos 0)) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-var-decl-node-p (js2-export-node-declaration export-node))))) + +(js2-deftest export-class-declaration "export class Foo {}" + (js2-init-scanner) + (js2-push-scope (make-js2-scope :pos 0)) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-class-node-p (js2-export-node-declaration export-node))))) + +(js2-deftest export-function-declaration "export default function doStuff() {}" + (js2-init-scanner) + (js2-push-scope (make-js2-scope :pos 0)) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-export-node-default export-node)))) + +(js2-deftest export-generator-declaration "export default function* one() {}" + (js2-init-scanner) + (js2-push-scope (make-js2-scope :pos 0)) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-export-node-default export-node)))) + +(js2-deftest export-assignment-expression "export default a = b;" + (js2-init-scanner) + (js2-push-scope (make-js2-scope :pos 0)) + (should (js2-match-token js2-EXPORT)) + (let ((export-node (js2-parse-export))) + (should export-node) + (should (js2-export-node-default export-node)))) + +(js2-deftest export-function-no-semicolon "export default function foo() {}" + (js2-mode--and-parse) + (should (null js2-parsed-warnings))) +(js2-deftest export-default-function-no-semicolon "export function foo() {}" + (js2-mode--and-parse) + (should (null js2-parsed-warnings))) +(js2-deftest export-anything-else-does-require-a-semicolon "export var obj = {}" + (js2-mode--and-parse) + (should (not (null js2-parsed-warnings)))) + +(js2-deftest export-default-async-function-no-semicolon "export default async function foo() {}" + (js2-mode--and-parse) + (should (null js2-parsed-warnings))) +(js2-deftest export-async-function-no-semicolon "export async function foo() {}" + (js2-mode--and-parse) + (should (null js2-parsed-warnings))) + +(js2-deftest-parse parse-export-rexport "export * from 'other/lib';") +(js2-deftest-parse parse-export-export-named-list "export {foo, bar as bang};") +(js2-deftest-parse parse-re-export-named-list "export {foo, bar as bang} from 'other/lib';") +(js2-deftest-parse parse-export-const-declaration "export const PI = Math.PI;") +(js2-deftest-parse parse-export-let-declaration "export let foo = [1];") +(js2-deftest-parse parse-export-default-function "export default function() {}") +(js2-deftest-parse parse-export-default-generator "export default function*() {}") +(js2-deftest-parse parse-export-default-class "export default class {\n}") +(js2-deftest-parse parse-export-assignment-expression "export default a = b;") + +(js2-deftest-parse parse-export-function-declaration-no-semi + "export function f() {\n}") + +(js2-deftest-parse parse-export-class-declaration-no-semi + "export class C {\n}") + +(js2-deftest-parse parse-export-async-function-allow-await + "export async function f() {\n await f();\n}") + +(js2-deftest-parse parse-export-default-async-function-allow-await + "export default async function f() {\n await f();\n}") + +;;; Strings + +(js2-deftest-parse string-literal + "var x = 'y';") + +(js2-deftest-parse object-get-string-literal + "var x = {y: 5};\nvar z = x[\"y\"];") + +(js2-deftest-parse template-no-substritutions + "var x = `abc + def`, y = `\\u0000`;") + +(js2-deftest-parse template-with-substitutions + "var y = `${a + b} ${d + e + f}`;") + +(js2-deftest-parse tagged-template + "foo.args`${++x, \"o\"}k`;") + +;;; Classes + +(js2-deftest-parse parse-harmony-class-statement + "class Foo {\n get bar() { return 42;\n}\n set bar(x) { y = x;\n}\n}") + +(js2-deftest-parse parse-harmony-class-statement-without-name-is-not-ok + "class {\n get bar() { return 42;\n}\n}" + :syntax-error "{") + +(js2-deftest-parse parse-harmony-class-expression + "var Foo1 = class Foo {\n bar() { return 42;\n}\n};") + +(js2-deftest-parse parse-harmony-anonymous-class-expression + "var Foo = class {\n set bar(x) { bar = x;\n}\n};") + +(js2-deftest-parse parse-harmony-class-with-extends + "class Foo extends Bar {\n}") + +(js2-deftest-parse parse-harmony-anonymous-class-with-extends + "foo.Foo = class extends Bar {\n set bar(x) { bar = x;\n}\n};") + +(js2-deftest-parse parse-harmony-class-with-complex-extends + "class Foo extends foo[BAR][2].Baz {\n}") + +(js2-deftest-parse parse-harmony-class-missing-extended-class-is-not-ok + "class Foo extends {\n}" + :syntax-error "extends") + +(js2-deftest-parse parse-harmony-class-static-method + "class Foo extends Bar {\n static bar() { return 42;\n}\n}") + +(js2-deftest-parse parse-unterminated-class-is-not-okay + "class Foo {\n get bar() { return 42;\n}" + :syntax-error "}") + +(js2-deftest-parse parse-super-keyword + "class Foo {\n constructor() { super(42);\n}\n foo() { super.foo();\n}\n}") + +(js2-deftest-parse parse-class-keywordlike-method + "class C {\n delete() {}\n if() {}\n}") + +(js2-deftest-parse parse-harmony-class-allow-semicolon-element + "class Foo {;}" :reference "class Foo {\n}") + +(js2-deftest-parse parse-class-public-field-with-init + "class C {\n x = 42;\n y = 24;\n \"z\" = 1\n 456 = 789\n}" + :reference "class C {\n x = 42\n y = 24\n \"z\" = 1\n 456 = 789\n}") + +(js2-deftest-parse parse-class-public-field-no-init + "class C {\n x\n y\n \"z\"\n 456\n}") + +(js2-deftest-parse parse-class-public-field-computed + "class C {\n [a + b] = c\n}") + +;;; Operators + +(js2-deftest-parse exponentiation + "a **= b ** c ** d * e ** f;") + +(js2-deftest-parse exponentiation-prohibits-unary-op + "var a = -b ** c" :syntax-error "-b") + +(js2-deftest unary-void-node-start + "var c = void 0" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "void 0")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "0")))) + +(js2-deftest unary-pos-node-start + "var a = +1;" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "+1")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "1")))) + +(js2-deftest unary-minus-node-start + "var a = -1;" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "-1")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "1")))) + +(js2-deftest unary-await-node-start + "var f = async () => await p;" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "await p")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "p")))) + +(js2-deftest unary-inc-node-start + "var a = 1; a++;" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "a++")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "a")))) + +(js2-deftest unary-delete-node-start + "var a = {b: 2}; delete a.b;" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "delete a.b")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "a.b")))) + +(js2-deftest unary-triple-dot-arg-node-start + "var b = f(...args)" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "...args")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "args")))) + +(js2-deftest unary-triple-dot-array-node-start + "var a = [1, 2, ...b]" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "...b")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "b")))) + +(js2-deftest unary-triple-dot-object-node-start + "var a = {x: 1, y: 2, ...z}" + (js2-mode--and-parse) + (let ((node (js2-find-node js2-mode-ast 'js2-unary-node-p))) + (should node) + (should (string= (js2-node-text node) "...z")) + (should (string= (js2-node-text (js2-unary-node-operand node)) "z")))) + +;;; Scopes + +(js2-deftest ast-symbol-table-includes-fn-node "function foo() {}" + (js2-mode--and-parse) + (let ((entry (js2-scope-get-symbol js2-mode-ast 'foo))) + (should (= (js2-symbol-decl-type entry) js2-FUNCTION)) + (should (equal (js2-symbol-name entry) "foo")) + (should (js2-function-node-p (js2-symbol-ast-node entry))))) + +(js2-deftest fn-symbol-table-includes-nested-fn "function foo() { + function bar() {} + var x; +}" + (js2-mode--and-parse) + (let* ((scope (js2-node-at-point (point-min))) + (fn-entry (js2-scope-get-symbol scope 'bar)) + (var-entry (js2-scope-get-symbol scope 'x))) + (should (string= (js2-name-node-name (js2-function-node-name scope)) "foo")) + (should (= (js2-symbol-decl-type fn-entry) js2-FUNCTION)) + (should (js2-function-node-p (js2-symbol-ast-node fn-entry))) + (should (= (js2-symbol-decl-type var-entry) js2-VAR)) + (should (js2-name-node-p (js2-symbol-ast-node var-entry))))) + +(defun js2-test-scope-of-nth-variable-satisifies-predicate (variable nth predicate) + (goto-char (point-min)) + (dotimes (n (1+ nth)) (search-forward variable)) + (forward-char -1) + (let ((scope (js2-node-get-enclosing-scope (js2-node-at-point)))) + (should (funcall predicate (js2-get-defining-scope scope variable))))) + +(js2-deftest for-node-is-declaration-scope "for (let i = 0; i; ++i) {};" + (js2-mode--and-parse) + (js2-test-scope-of-nth-variable-satisifies-predicate "i" 0 #'js2-for-node-p)) + +(js2-deftest const-scope-inside-script "{ const a; } a;" + (js2-mode--and-parse) + (js2-test-scope-of-nth-variable-satisifies-predicate "a" 0 #'js2-block-node-p) + (js2-test-scope-of-nth-variable-satisifies-predicate "a" 1 #'null)) + +(js2-deftest const-scope-inside-function "function f() { { const a; } a; }" + (js2-mode--and-parse) + (js2-test-scope-of-nth-variable-satisifies-predicate "a" 0 #'js2-block-node-p) + (js2-test-scope-of-nth-variable-satisifies-predicate "a" 1 #'null)) + +(js2-deftest array-comp-is-result-scope "[x * 2 for (x in y)];" + (js2-mode--and-parse) + (js2-test-scope-of-nth-variable-satisifies-predicate "x" 0 #'js2-comp-loop-node-p)) + +(js2-deftest array-comp-has-parent-scope + "var a,b=[for (i of [[1,2]]) for (j of i) j * a];" + (js2-mode--and-parse) + (search-forward "for") + (forward-char -3) + (let ((node (js2-node-at-point))) + (should (js2-scope-parent-scope node)) + (should (js2-get-defining-scope node "j")))) + +;;; Tokenizer + +(js2-deftest get-token "(1+1)" + (js2-init-scanner) + (should (eq js2-LP (js2-next-token))) + (should (eq js2-NUMBER (js2-next-token))) + (should (eq js2-ADD (js2-next-token))) + (should (eq js2-NUMBER (js2-next-token))) + (should (eq js2-RP (js2-next-token)))) + +(js2-deftest unget-token "()" + (js2-init-scanner) + (should (eq js2-LP (js2-next-token))) + (js2-unget-token) + (should (eq js2-LP (js2-next-token))) + (should (eq js2-RP (js2-next-token)))) + +(js2-deftest get-token-or-eol "x\n++;" + (js2-init-scanner) + (should (eq js2-NAME (js2-next-token))) + (should (eq js2-EOL (js2-peek-token-or-eol))) + (should (eq js2-INC (js2-next-token))) + (should (eq js2-SEMI (js2-peek-token-or-eol)))) + +(js2-deftest unget-token-over-eol-and-comment "x\n//abc\ny" + (js2-init-scanner) + (should (eq js2-NAME (js2-next-token))) + (should (eq js2-NAME (js2-next-token))) + (should (equal "y" (js2-current-token-string))) + (js2-unget-token) + (should (eq js2-NAME (js2-current-token-type))) + (should (equal "x" (js2-current-token-string)))) + +(js2-deftest ts-seek "(1+2)" + (js2-init-scanner) + (should (eq js2-LP (js2-next-token))) + (should (eq js2-NUMBER (js2-next-token))) + (js2-unget-token) + (let ((state (make-js2-ts-state))) + (should (eq js2-NUMBER (js2-next-token))) + (should (eq js2-ADD (js2-next-token))) + (js2-ts-seek state) + (should (eq 1 js2-ti-lookahead)) + (should (eq js2-NUMBER (js2-next-token))) + (should (eq 1 (js2-token-number + (js2-current-token)))))) + +(js2-deftest get-token-template-literal "`abc ${i} z ${j} def`" + (js2-init-scanner) + (should (eq js2-TEMPLATE_HEAD (js2-next-token))) + (should (equal "abc " (js2-current-token-string))) + (should (eq js2-NAME (js2-next-token))) + (should (eq js2-RC (js2-next-token))) + (should (eq js2-TEMPLATE_HEAD (js2-next-token 'TEMPLATE_TAIL))) + (should (equal " z " (js2-current-token-string))) + (should (eq js2-NAME (js2-next-token))) + (should (eq js2-RC (js2-next-token))) + (should (eq js2-NO_SUBS_TEMPLATE (js2-next-token 'TEMPLATE_TAIL))) + (should (equal " def" (js2-current-token-string)))) + +;;; Error handling + +(js2-deftest for-node-with-error-len "for " + (js2-mode--and-parse) + (let ((node (js2-node-at-point (point-min)))) + (should (= (js2-node-len (js2-node-parent node)) 4)))) + +(js2-deftest function-without-parens-error "function b {}" + ;; Should finish the parse. + (js2-mode--and-parse)) + +;;; Comments + +(js2-deftest comment-node-length "//" + (js2-mode--and-parse) + (let ((node (js2-node-at-point (point-min)))) + (should (= (js2-node-len node) 2)))) + +(js2-deftest comment-node-length-newline "//\n" + (js2-mode--and-parse) + (let ((node (js2-node-at-point (point-min)))) + (should (= (js2-node-len node) 3)))) + +;;; Variables classification + +(defun js2--variables-summary (vars) + (let (r) + (setq vars (let (aslist) + (maphash (lambda (k v) (push (cons k v) aslist)) vars) + aslist)) + (dolist (v (sort vars (lambda (a b) (< (js2-node-abs-pos (js2-symbol-ast-node (car a))) + (js2-node-abs-pos (js2-symbol-ast-node (car b))))))) + (let* ((symbol (car v)) + (inition (cadr v)) + (uses (cddr v)) + (symn (js2-symbol-ast-node symbol)) + (namen (js2--get-name-node symn))) + (push (format "%s@%s:%s" + (js2-symbol-name symbol) + (js2-node-abs-pos namen) + (if (eq inition ?P) + "P" + (if uses + (if inition "I" "N") + "U"))) r) + (dolist (u (sort (cddr v) (lambda (a b) (< (js2-node-abs-pos a) + (js2-node-abs-pos b))))) + (push (js2-node-abs-pos u) r)))) + (reverse r))) + +(defmacro js2-deftest-classify-variables (name buffer-contents summary) + (declare (indent defun)) + `(ert-deftest ,(intern (format "js2-classify-variables-%s" name)) () + (with-temp-buffer + (save-excursion + (insert ,buffer-contents)) + (unwind-protect + (progn + (js2-mode--and-parse) + (should (equal ,summary (js2--variables-summary + (js2--classify-variables))))) + (fundamental-mode))))) + +(js2-deftest-classify-variables incomplete-var-statement + "var" + '()) + +(js2-deftest-classify-variables unused-variable + "function foo () { var x; return 42; }" + '("foo@10:U" "x@23:U")) + +(js2-deftest-classify-variables unused-variable-declared-twice + "function foo (a) { var x; function bar () { var x; x=42; }; return a;}" + '("foo@10:U" "a@15:P" 68 "x@24:U" "bar@36:U" "x@49:U")) + +(js2-deftest-classify-variables assigned-variable + "function foo () { var x; x=42; return x; }" + '("foo@10:U" "x@23:I" 39)) + +(js2-deftest-classify-variables assignment-in-nested-function + "function foo () { var x; function bar () { x=42; }; }" + '("foo@10:U" "x@23:U" "bar@35:U")) + +(js2-deftest-classify-variables unused-nested-function + "function foo() { var i, j=1; function bar() { var x, y=42, z=i; return y; } return i; }" + '("foo@10:U" "i@22:N" 62 84 "j@25:U" "bar@39:U" "x@51:U" "y@54:I" 72 "z@60:U")) + +(js2-deftest-classify-variables prop-get-initialized + "function foo () { var x, y={}; y.a=x; }" + '("foo@10:U" "x@23:N" 36 "y@26:I" 32)) + +(js2-deftest-classify-variables prop-get-uninitialized + "function foo () { var x; if(x.foo) alert('boom'); }" + '("foo@10:U" "x@23:N" 29)) + +(js2-deftest-classify-variables prop-get-function-assignment + "(function(w) { w.f = function() { var a=42, m; return a; }; })(window);" + '("w@11:P" 16 "a@39:I" 55 "m@45:U")) + +(js2-deftest-classify-variables let-declaration + "function foo () { let x,y=1; return x; }" + '("foo@10:U" "x@23:N" 37 "y@25:U")) + +(js2-deftest-classify-variables external-function-call + "function foo (m) { console.log(m, arguments); }" + '("foo@10:U" "m@15:P" 32)) + +(js2-deftest-classify-variables global-function-call + "function bar () { return 42; } function foo (a) { return bar(); }" + '("bar@10:I" 58 "foo@41:U" "a@46:P")) + +(js2-deftest-classify-variables let-declaration-for-scope + "function foo () { for(let x=1,y; x<y; y++) {} }" + '("foo@10:U" "x@27:I" 34 "y@31:N" 36 39)) + +(js2-deftest-classify-variables arguments-implicit-var + "function foo () { var p; for(p in arguments) { return p; } }" + '("foo@10:U" "p@23:I" 55)) + +(js2-deftest-classify-variables catch-error-variable + "function foo () { try { throw 'Foo'; } catch (e) { console.log(e); }" + '("foo@10:U" "e@47:I" 64)) + +(js2-deftest-classify-variables prop-get-assignment + "function foo () { var y,x={y:{z:{}}}; x.y.z=42; }" + '("foo@10:U" "y@23:U" "x@25:I" 39)) + +(js2-deftest-classify-variables unused-function-argument + "function foo (a) { return 42; }" + '("foo@10:U" "a@15:P")) + +(js2-deftest-classify-variables used-function-argument + "function foo (a) { a=42; return a; }" + '("foo@10:U" "a@15:P" 33)) + +(js2-deftest-classify-variables prop-get + "function foo (a) { a=navigator.x||navigator.y; return a; }" + '("foo@10:U" "a@15:P" 55)) + +(js2-deftest-classify-variables for-in-loop + "function foo () { var d={}; for(var k in d) {var v=d[k]; } }" + '("foo@10:U" "d@23:I" 42 52 "k@37:I" 54 "v@50:U")) + +(js2-deftest-classify-variables array-comprehension-legacy + "function foo() { var j,a=[for (i of [1,2,3]) i*j]; }" + '("foo@10:U" "j@22:N" 48 "a@24:U" "i@32:I" 46)) + +(js2-deftest-classify-variables array-comprehension + "function foo() { var j,a=[[i,j] for (i of [1,2,3])]; }" + '("foo@10:U" "j@22:N" 30 "a@24:U" "i@38:I" 28)) + +(js2-deftest-classify-variables return-named-function + "function foo() { var a=42; return function bar() { return a; }; }" + '("foo@10:U" "a@22:I" 59 "bar@44:U")) + +(js2-deftest-classify-variables named-wrapper-function + "function foo() { var a; (function bar() { a=42; })(); return a; }" + '("foo@10:U" "a@22:I" 62 "bar@35:I" 35)) + +(js2-deftest-classify-variables destructure-array + "function foo(x,y) { let [u,v] = [x,y]; }" + '("foo@10:U" "x@14:P" 34 "y@16:P" 36 "u@26:U" "v@28:U")) + +(js2-deftest-classify-variables destructure-object + "function foo(x,y) { var {p: [, w], q: z} = {p: [x, 2, 3], q: y}; }" + '("foo@10:U" "x@14:P" 49 "y@16:P" 62 "w@32:U" "z@39:U")) + +(js2-deftest-classify-variables destructure-object-shorthand + "function foo(x,y) { var {p, q} = {p: x, q: y}; }" + '("foo@10:U" "x@14:P" 38 "y@16:P" 44 "p@26:U" "q@29:U")) + +(js2-deftest-classify-variables destructure-object-mixed + "function foo() { let {a, b, c = 3} = {a: 1, b: 2}; }" + '("foo@10:U" "a@23:U" "b@26:U" "c@29:U")) + +(js2-deftest-classify-variables destructure-object-missing + "function foo() { let {foo: missing = 10} = {}; }" + '("foo@10:U" "missing@28:U")) + +(js2-deftest-classify-variables import-unused + "import foo from 'module';" + '("foo@8:U")) + +(js2-deftest-classify-variables named-import-unused + "import foo as bar from 'module';" + '("bar@15:U")) + +(js2-deftest-classify-variables import-unused-many + "import {a,b} from 'module';" + '("a@9:U" "b@11:U")) + +(js2-deftest-classify-variables named-import-unused-many + "import {a as b, c as d} from 'module';" + '("b@14:U" "d@22:U")) + +(js2-deftest-classify-variables import-export + "import foo from 'module'; export {foo}" + '("foo@8:I" 35)) + +(js2-deftest-classify-variables import-namespace-unused + "import * as foo from 'module';" + '("foo@13:U")) + +(js2-deftest-classify-variables import-namespace-used + "import * as foo from 'module'; function bar() { return foo.x; }" + '("foo@13:I" 56 "bar@41:U")) + +;; Side effects + +(js2-deftest no-side-effects-at-top-level + "var x; x.foo;" + (js2-mode--and-parse) + (should (null js2-parsed-warnings))) + +(js2-deftest getprop-has-no-side-effects + "function f() { this.x; }" + (js2-mode--and-parse) + (should (equal "msg.no.side.effects" + (car (caar js2-parsed-warnings))))) + +(js2-deftest getprop-has-side-effects-option + "function f() { this.x; }" + (let ((js2-getprop-has-side-effects t)) + (js2-mode--and-parse) + (should (null js2-parsed-warnings)))) + +(js2-deftest arithmetic-has-no-side-effects + "function f() { 1 + 2; }" + (js2-mode--and-parse) + (should (equal "msg.no.side.effects" + (car (caar js2-parsed-warnings))))) + +(js2-deftest instanceof-has-no-side-effects + "function f() { this instanceof f; }" + (js2-mode--and-parse) + (should (equal "msg.no.side.effects" + (car (caar js2-parsed-warnings))))) + +(js2-deftest instanceof-has-side-effects-option + "function f() { this instanceof f; }" + (let ((js2-instanceof-has-side-effects t)) + (js2-mode--and-parse) + (should (null js2-parsed-warnings)))) + +(js2-deftest await-has-side-effects + "const p = new Promise();\nasync function f() { await p; return null; }" + (js2-mode--and-parse) + (should (null js2-parsed-warnings)))