packages feed

glualint (empty) → 1.24.6

raw patch · 29 files changed

+34660/−0 lines, 29 filesdep +aesondep +basedep +bytestring

Dependencies added: aeson, base, bytestring, containers, deepseq, directory, effectful, filemanip, filepath, glualint, optparse-applicative, parsec, pretty, signal, uu-parsinglib, uuagc, uuagc-cabal

Files

+ LICENSE view
@@ -0,0 +1,502 @@+                  GNU LESSER GENERAL PUBLIC LICENSE+                       Version 2.1, February 1999++ Copyright (C) 1991, 1999 Free Software Foundation, Inc.+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++[This is the first released version of the Lesser GPL.  It also counts+ as the successor of the GNU Library Public License, version 2, hence+ the version number 2.1.]++                            Preamble++  The licenses for most software are designed to take away your+freedom to share and change it.  By contrast, the GNU General Public+Licenses are intended to guarantee your freedom to share and change+free software--to make sure the software is free for all its users.++  This license, the Lesser General Public License, applies to some+specially designated software packages--typically libraries--of the+Free Software Foundation and other authors who decide to use it.  You+can use it too, but we suggest you first think carefully about whether+this license or the ordinary General Public License is the better+strategy to use in any particular case, based on the explanations below.++  When we speak of free software, we are referring to freedom of use,+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 this service if you wish); that you receive source code or can get+it if you want it; that you can change the software and use pieces of+it in new free programs; and that you are informed that you can do+these things.++  To protect your rights, we need to make restrictions that forbid+distributors to deny you these rights or to ask you to surrender these+rights.  These restrictions translate to certain responsibilities for+you if you distribute copies of the library or if you modify it.++  For example, if you distribute copies of the library, whether gratis+or for a fee, you must give the recipients all the rights that we gave+you.  You must make sure that they, too, receive or can get the source+code.  If you link other code with the library, you must provide+complete object files to the recipients, so that they can relink them+with the library after making changes to the library and recompiling+it.  And you must show them these terms so they know their rights.++  We protect your rights with a two-step method: (1) we copyright the+library, and (2) we offer you this license, which gives you legal+permission to copy, distribute and/or modify the library.++  To protect each distributor, we want to make it very clear that+there is no warranty for the free library.  Also, if the library is+modified by someone else and passed on, the recipients should know+that what they have is not the original version, so that the original+author's reputation will not be affected by problems that might be+introduced by others.++  Finally, software patents pose a constant threat to the existence of+any free program.  We wish to make sure that a company cannot+effectively restrict the users of a free program by obtaining a+restrictive license from a patent holder.  Therefore, we insist that+any patent license obtained for a version of the library must be+consistent with the full freedom of use specified in this license.++  Most GNU software, including some libraries, is covered by the+ordinary GNU General Public License.  This license, the GNU Lesser+General Public License, applies to certain designated libraries, and+is quite different from the ordinary General Public License.  We use+this license for certain libraries in order to permit linking those+libraries into non-free programs.++  When a program is linked with a library, whether statically or using+a shared library, the combination of the two is legally speaking a+combined work, a derivative of the original library.  The ordinary+General Public License therefore permits such linking only if the+entire combination fits its criteria of freedom.  The Lesser General+Public License permits more lax criteria for linking other code with+the library.++  We call this license the "Lesser" General Public License because it+does Less to protect the user's freedom than the ordinary General+Public License.  It also provides other free software developers Less+of an advantage over competing non-free programs.  These disadvantages+are the reason we use the ordinary General Public License for many+libraries.  However, the Lesser license provides advantages in certain+special circumstances.++  For example, on rare occasions, there may be a special need to+encourage the widest possible use of a certain library, so that it becomes+a de-facto standard.  To achieve this, non-free programs must be+allowed to use the library.  A more frequent case is that a free+library does the same job as widely used non-free libraries.  In this+case, there is little to gain by limiting the free library to free+software only, so we use the Lesser General Public License.++  In other cases, permission to use a particular library in non-free+programs enables a greater number of people to use a large body of+free software.  For example, permission to use the GNU C Library in+non-free programs enables many more people to use the whole GNU+operating system, as well as its variant, the GNU/Linux operating+system.++  Although the Lesser General Public License is Less protective of the+users' freedom, it does ensure that the user of a program that is+linked with the Library has the freedom and the wherewithal to run+that program using a modified version of the Library.++  The precise terms and conditions for copying, distribution and+modification follow.  Pay close attention to the difference between a+"work based on the library" and a "work that uses the library".  The+former contains code derived from the library, whereas the latter must+be combined with the library in order to run.++                  GNU LESSER GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++  0. This License Agreement applies to any software library or other+program which contains a notice placed by the copyright holder or+other authorized party saying it may be distributed under the terms of+this Lesser General Public License (also called "this License").+Each licensee is addressed as "you".++  A "library" means a collection of software functions and/or data+prepared so as to be conveniently linked with application programs+(which use some of those functions and data) to form executables.++  The "Library", below, refers to any such software library or work+which has been distributed under these terms.  A "work based on the+Library" means either the Library or any derivative work under+copyright law: that is to say, a work containing the Library or a+portion of it, either verbatim or with modifications and/or translated+straightforwardly into another language.  (Hereinafter, translation is+included without limitation in the term "modification".)++  "Source code" for a work means the preferred form of the work for+making modifications to it.  For a library, complete source code means+all the source code for all modules it contains, plus any associated+interface definition files, plus the scripts used to control compilation+and installation of the library.++  Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope.  The act of+running a program using the Library is not restricted, and output from+such a program is covered only if its contents constitute a work based+on the Library (independent of the use of the Library in a tool for+writing it).  Whether that is true depends on what the Library does+and what the program that uses the Library does.++  1. You may copy and distribute verbatim copies of the Library's+complete source code as you receive it, in any medium, provided that+you conspicuously and appropriately publish on each copy an+appropriate copyright notice and disclaimer of warranty; keep intact+all the notices that refer to this License and to the absence of any+warranty; and distribute a copy of this License along with the+Library.++  You may charge a fee for the physical act of transferring a copy,+and you may at your option offer warranty protection in exchange for a+fee.++  2. You may modify your copy or copies of the Library or any portion+of it, thus forming a work based on the Library, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++    a) The modified work must itself be a software library.++    b) You must cause the files modified to carry prominent notices+    stating that you changed the files and the date of any change.++    c) You must cause the whole of the work to be licensed at no+    charge to all third parties under the terms of this License.++    d) If a facility in the modified Library refers to a function or a+    table of data to be supplied by an application program that uses+    the facility, other than as an argument passed when the facility+    is invoked, then you must make a good faith effort to ensure that,+    in the event an application does not supply such function or+    table, the facility still operates, and performs whatever part of+    its purpose remains meaningful.++    (For example, a function in a library to compute square roots has+    a purpose that is entirely well-defined independent of the+    application.  Therefore, Subsection 2d requires that any+    application-supplied function or table used by this function must+    be optional: if the application does not supply it, the square+    root function must still compute square roots.)++These requirements apply to the modified work as a whole.  If+identifiable sections of that work are not derived from the Library,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works.  But when you+distribute the same sections as part of a whole which is a work based+on the Library, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote+it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Library.++In addition, mere aggregation of another work not based on the Library+with the Library (or with a work based on the Library) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++  3. You may opt to apply the terms of the ordinary GNU General Public+License instead of this License to a given copy of the Library.  To do+this, you must alter all the notices that refer to this License, so+that they refer to the ordinary GNU General Public License, version 2,+instead of to this License.  (If a newer version than version 2 of the+ordinary GNU General Public License has appeared, then you can specify+that version instead if you wish.)  Do not make any other change in+these notices.++  Once this change is made in a given copy, it is irreversible for+that copy, so the ordinary GNU General Public License applies to all+subsequent copies and derivative works made from that copy.++  This option is useful when you wish to copy part of the code of+the Library into a program that is not a library.++  4. You may copy and distribute the Library (or a portion or+derivative of it, under Section 2) in object code or executable form+under the terms of Sections 1 and 2 above provided that you accompany+it with the complete corresponding machine-readable source code, which+must be distributed under the terms of Sections 1 and 2 above on a+medium customarily used for software interchange.++  If distribution of object code is made by offering access to copy+from a designated place, then offering equivalent access to copy the+source code from the same place satisfies the requirement to+distribute the source code, even though third parties are not+compelled to copy the source along with the object code.++  5. A program that contains no derivative of any portion of the+Library, but is designed to work with the Library by being compiled or+linked with it, is called a "work that uses the Library".  Such a+work, in isolation, is not a derivative work of the Library, and+therefore falls outside the scope of this License.++  However, linking a "work that uses the Library" with the Library+creates an executable that is a derivative of the Library (because it+contains portions of the Library), rather than a "work that uses the+library".  The executable is therefore covered by this License.+Section 6 states terms for distribution of such executables.++  When a "work that uses the Library" uses material from a header file+that is part of the Library, the object code for the work may be a+derivative work of the Library even though the source code is not.+Whether this is true is especially significant if the work can be+linked without the Library, or if the work is itself a library.  The+threshold for this to be true is not precisely defined by law.++  If such an object file uses only numerical parameters, data+structure layouts and accessors, and small macros and small inline+functions (ten lines or less in length), then the use of the object+file is unrestricted, regardless of whether it is legally a derivative+work.  (Executables containing this object code plus portions of the+Library will still fall under Section 6.)++  Otherwise, if the work is a derivative of the Library, you may+distribute the object code for the work under the terms of Section 6.+Any executables containing that work also fall under Section 6,+whether or not they are linked directly with the Library itself.++  6. As an exception to the Sections above, you may also combine or+link a "work that uses the Library" with the Library to produce a+work containing portions of the Library, and distribute that work+under terms of your choice, provided that the terms permit+modification of the work for the customer's own use and reverse+engineering for debugging such modifications.++  You must give prominent notice with each copy of the work that the+Library is used in it and that the Library and its use are covered by+this License.  You must supply a copy of this License.  If the work+during execution displays copyright notices, you must include the+copyright notice for the Library among them, as well as a reference+directing the user to the copy of this License.  Also, you must do one+of these things:++    a) Accompany the work with the complete corresponding+    machine-readable source code for the Library including whatever+    changes were used in the work (which must be distributed under+    Sections 1 and 2 above); and, if the work is an executable linked+    with the Library, with the complete machine-readable "work that+    uses the Library", as object code and/or source code, so that the+    user can modify the Library and then relink to produce a modified+    executable containing the modified Library.  (It is understood+    that the user who changes the contents of definitions files in the+    Library will not necessarily be able to recompile the application+    to use the modified definitions.)++    b) Use a suitable shared library mechanism for linking with the+    Library.  A suitable mechanism is one that (1) uses at run time a+    copy of the library already present on the user's computer system,+    rather than copying library functions into the executable, and (2)+    will operate properly with a modified version of the library, if+    the user installs one, as long as the modified version is+    interface-compatible with the version that the work was made with.++    c) Accompany the work with a written offer, valid for at+    least three years, to give the same user the materials+    specified in Subsection 6a, above, for a charge no more+    than the cost of performing this distribution.++    d) If distribution of the work is made by offering access to copy+    from a designated place, offer equivalent access to copy the above+    specified materials from the same place.++    e) Verify that the user has already received a copy of these+    materials or that you have already sent this user a copy.++  For an executable, the required form of the "work that uses the+Library" must include any data and utility programs needed for+reproducing the executable from it.  However, as a special exception,+the materials to be distributed need not include anything that is+normally distributed (in either source or binary form) with the major+components (compiler, kernel, and so on) of the operating system on+which the executable runs, unless that component itself accompanies+the executable.++  It may happen that this requirement contradicts the license+restrictions of other proprietary libraries that do not normally+accompany the operating system.  Such a contradiction means you cannot+use both them and the Library together in an executable that you+distribute.++  7. You may place library facilities that are a work based on the+Library side-by-side in a single library together with other library+facilities not covered by this License, and distribute such a combined+library, provided that the separate distribution of the work based on+the Library and of the other library facilities is otherwise+permitted, and provided that you do these two things:++    a) Accompany the combined library with a copy of the same work+    based on the Library, uncombined with any other library+    facilities.  This must be distributed under the terms of the+    Sections above.++    b) Give prominent notice with the combined library of the fact+    that part of it is a work based on the Library, and explaining+    where to find the accompanying uncombined form of the same work.++  8. You may not copy, modify, sublicense, link with, or distribute+the Library except as expressly provided under this License.  Any+attempt otherwise to copy, modify, sublicense, link with, or+distribute the Library is void, and will automatically terminate your+rights under this License.  However, parties who have received copies,+or rights, from you under this License will not have their licenses+terminated so long as such parties remain in full compliance.++  9. You are not required to accept this License, since you have not+signed it.  However, nothing else grants you permission to modify or+distribute the Library or its derivative works.  These actions are+prohibited by law if you do not accept this License.  Therefore, by+modifying or distributing the Library (or any work based on the+Library), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Library or works based on it.++  10. Each time you redistribute the Library (or any work based on the+Library), the recipient automatically receives a license from the+original licensor to copy, distribute, link with or modify the Library+subject to these terms and conditions.  You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties with+this License.++  11. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+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+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Library at all.  For example, if a patent+license would not permit royalty-free redistribution of the Library by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Library.++If any portion of this section is held invalid or unenforceable under any+particular circumstance, the balance of the section is intended to apply,+and the section as a whole is intended to apply in other circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system which is+implemented by public license practices.  Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++  12. If the distribution and/or use of the Library is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Library under this License may add+an explicit geographical distribution limitation excluding those countries,+so that distribution is permitted only in or among countries not thus+excluded.  In such case, this License incorporates the limitation as if+written in the body of this License.++  13. The Free Software Foundation may publish revised and/or new+versions of the Lesser 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 Library+specifies a version number of this License which applies to it and+"any later version", you have the option of following the terms and+conditions either of that version or of any later version published by+the Free Software Foundation.  If the Library does not specify a+license version number, you may choose any version ever published by+the Free Software Foundation.++  14. If you wish to incorporate parts of the Library into other free+programs whose distribution conditions are incompatible with these,+write to the author to ask for permission.  For software which is+copyrighted by the Free Software Foundation, write to the Free+Software Foundation; we sometimes make exceptions for this.  Our+decision will be guided by the two goals of preserving the free status+of all derivatives of our free software and of promoting the sharing+and reuse of software generally.++                            NO WARRANTY++  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR+OTHER PARTIES PROVIDE THE LIBRARY "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+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY+AND/OR REDISTRIBUTE THE LIBRARY 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+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH+DAMAGES.++                     END OF TERMS AND CONDITIONS++           How to Apply These Terms to Your New Libraries++  If you develop a new library, and you want it to be of the greatest+possible use to the public, we recommend making it free software that+everyone can redistribute and change.  You can do so by permitting+redistribution under these terms (or, alternatively, under the terms of the+ordinary General Public License).++  To apply these terms, attach the following notices to the library.  It is+safest to attach them to the start of each source file to most effectively+convey 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 library's name and a brief idea of what it does.>+    Copyright (C) <year>  <name of author>++    This library is free software; you can redistribute it and/or+    modify it under the terms of the GNU Lesser General Public+    License as published by the Free Software Foundation; either+    version 2.1 of the License, or (at your option) any later version.++    This library 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+    Lesser General Public License for more details.++    You should have received a copy of the GNU Lesser General Public+    License along with this library; if not, write to the Free Software+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA++Also add information on how to contact you by electronic and paper mail.++You should also get your employer (if you work as a programmer) or your+school, if any, to sign a "copyright disclaimer" for the library, if+necessary.  Here is a sample; alter the names:++  Yoyodyne, Inc., hereby disclaims all copyright interest in the+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.++  <signature of Ty Coon>, 1 April 1990+  Ty Coon, President of Vice++That's all there is to it!
+ README.md view
@@ -0,0 +1,215 @@+# glualint++glualint - Linter and pretty printer for Garry's Mod's variant of Lua.++## Installing++1. Download the latest version of `glualint` from [the releases page](https://github.com/FPtje/GLuaFixer/releases) OR [compile it yourself](https://github.com/FPtje/GLuaFixer/blob/master/Compiling.md). If you download for Linux, make sure to run the right version. Most computers will need the `x86_64` version. Embedded systems like a Raspberry pi will need the `aarch64-linux` version.+2. Place the `glualint` executable inside some folder.+3. Add the folder you put `glualint` in to your `PATH`. How this is done differs per operating system. If you're not sure how to do this, please Google `"Add to path <YOUR OS>"`.+4. Make sure you restart any terminals or text editors you currently have open.++After performing these steps, you can run `glualint` from the terminal or let your text editor use it as your linter. **Failing to specifically perform the third step will make `glualint` very unlikely to work**.++## Command line parameters++Parameter | Description+----------|------------+`--version` | Returns the version of glualint.+`--config` | Set to a `glualint.json` file for glualint configuration. See "Configuring glualint".+`--pretty-print` | Will pretty-print (re-structure/re-indent) all code given in stdin. When entering code in terminal, press Ctrl+D to finish the input.+`--pretty-print-files` | As above but pretty-prints the specified file or directory instead of stdin.+`--indentation='something'` | For pretty-print: indents all pretty-printed code with the given string. Four spaces by default, should probably some amount of tabs or spaces.+`--stdin` | Process stdin instead of specified file or directory when linting.+`--analyse-globals` | Show global variables/functions that this file defines.+`--test` | For debugging: test whether glualint works correctly on the given files and/or folders. Tries to parse with the two available parsers, then pretty prints and tries to parse the pretty printed result. It will show errors when it fails.++## Configuring glualint++`glualint` Allows some configuration. This is done through a file called `glualint.json` or `.glualint.json`. `glualint` looks for this file in three places (in order of priority)++- The file you give to the `--config` parameter (when using the terminal)+- Any folder above the file you're working in (e.g. the root of your project)+- Your home folder, which is `C:\users\yourusername\.glualint.json` on Windows or `/home/yourusername/.glualint.json` on Unix.++Note: The file **must** either be called `glualint.json` or `.glualint.json`.++Example `glualint.json` with the default options:++```json+{+    "lint_maxScopeDepth": 7,+    "lint_syntaxErrors": true,+    "lint_syntaxInconsistencies": true,+    "lint_deprecated": true,+    "lint_trailingWhitespace": true,+    "lint_whitespaceStyle": true,+    "lint_beginnerMistakes": true,+    "lint_emptyBlocks": true,+    "lint_shadowing": true,+    "lint_gotos": true,+    "lint_goto_identifier": true,+    "lint_doubleNegations": true,+    "lint_redundantIfStatements": true,+    "lint_redundantParentheses": true,+    "lint_duplicateTableKeys": true,+    "lint_profanity": true,+    "lint_unusedVars": true,+    "lint_unusedParameters": false,+    "lint_unusedLoopVars": false,+    "lint_inconsistentVariableStyle": false,+    "lint_spaceBetweenParens": false,+    "lint_spaceBetweenBrackets": false,+    "lint_spaceBetweenBraces": false,+    "lint_ignoreFiles": [],+    "lint_spaceBeforeComma": false,+    "lint_spaceAfterComma": false,+    "lint_maxLineLength": 0,++    "prettyprint_spaceBetweenParens": false,+    "prettyprint_spaceBetweenBrackets": false,+    "prettyprint_spaceBetweenBraces": false,+    "prettyprint_spaceEmptyParens": false,+    "prettyprint_spaceEmptyBraces": false,+    "prettyprint_spaceAfterLabel": false,+    "prettyprint_spaceBeforeComma": false,+    "prettyprint_spaceAfterComma": true,+    "prettyprint_semicolons": false,+    "prettyprint_cStyle": false,+    "prettyprint_removeRedundantParens": true,+    "prettyprint_minimizeParens": false,+    "prettyprint_assumeOperatorAssociativity": true,+    "prettyprint_rejectInvalidCode": false,+    "prettyprint_indentation": "    ",++    "log_format": "auto"+}+```++## All options explained++### Linter options++Option | Description+----------|------------+`lint_maxScopeDepth` | Maximum depth of scopes in your code. Any terrible scripter can build the most atrocious sideways code pyramids, usually without knowing. The number here is at which step the linter will start calling you out on it. Set to `0` if you're king Tut and want to disable it.+`lint_syntaxErrors` | Whether syntax errors should be reported. This is off by default because [`gluac`](https://github.com/cartman300/gluac) shows nicer syntax errors.+`lint_syntaxInconsistencies` | Warn for syntax inconsistencies (using both `&&` and `and`, that kind of stuff)+`lint_deprecated` | Warn for deprecated functions. These functions are taken from [the GMod wiki](http://wiki.garrysmod.com/page/Category:Deprecated_Functions), don't blame me for the things that are on there.+`lint_trailingWhitespace` | Warn for whitespace at the end of a line. Your editor should have an option to automatically trim trailing whitespace.+`lint_whitespaceStyle` | Warn for bad whitespace behaviour (e.g. lack of spaces around operators and keywords)+`lint_beginnerMistakes` | Warn for typical beginner mistakes (using self in non-metafunction, `net.WriteEntity(LocalPlayer())` in a net message, using self.Weapon in a SWEP etc.)+`lint_emptyBlocks` | Warn for empty blocks+`lint_shadowing` | Warn for variable shadowing+`lint_gotos` | Warn for inappropriate gotos (i.e. the ones not used to jump out of a double loop)+`lint_goto_identifier` | Warn when `goto` is used as an identifier (e.g. `a = {goto = 1}`). This warning exists because `goto` being allowed as identifier is actually a bug. You should not be able to use `goto` like that for the same reason you're not allowed to use any other keyword as identifier.+`lint_doubleNegations` | Warn for double negations (things like `not (a == b)`)+`lint_redundantIfStatements` | Warn for nested if-statements that can be combined with `and`+`lint_redundantParentheses` | Warn for unneeded parentheses around expressions.+`lint_duplicateTableKeys` | Warn for duplicate table keys (e.g. `{a = 1, a = 2}`)+`lint_profanity` | Warn for profanity (bitch, cock, cocks, cunt, dick, dicks, fuck, fucking, goddamnit, knob, knobs, motherfucker, nipple, shit)+`lint_unusedVars` | Warn for variables that are never used+`lint_unusedParameters` | Warn for function parameters that are never used. *NOTE:* Only has effect when `lint_unusedVars` is enabled!+`lint_unusedLoopVars` | Warn for loop variables that are never used (`for k,v in ...`). *NOTE:* Only has effect when `lint_unusedVars` is enabled!+`lint_ignoreFiles` | Files to ignore when linting. You can use glob patterns (e.g. `"**.lua"`, `"*.lua"` or `libraries/*.lua`)+`lint_inconsistentVariableStyle` | Whether to warn about inconsistent styles in naming local variables (e.g. lowercase and uppercase variables)+`lint_spaceBetweenParens` | Whether to warn about there being spaces between parentheses. This option used to be named `lint_spaceAfterParens`. For backwards compatibility that option still works.+`lint_spaceBetweenBrackets` | Whether to warn about there being spaces between brackets. This option used to be named `lint_spaceAfterBrackets`. For backwards compatibility that option still works.+`lint_spaceBetweenBraces` | Whether to warn about there being spaces between braces. This option used to be named `lint_spaceAfterBraces`. For backwards compatibility that option still works.+`lint_spaceBeforeComma` | Whether to warn about spaces before the comma. This option depends on `prettyprint_spaceBeforeComma` on whether the space is wanted.+`lint_spaceAfterComma` | Whether to warn about spaces after the comma. This option depends on `prettyprint_spaceAfterComma` on whether the space is wanted.+`lint_maxLineLength` | Warn for lines longer than the given number. Set to 0 to disable.++### Pretty print options++These options affect the pretty printing functionality of `glualint`.++Option | Description+----------|------------+`prettyprint_spaceBetweenParens` | Put a space between all parentheses+`prettyprint_spaceBetweenBrackets` | Put a space between all brackets+`prettyprint_spaceBetweenBraces` | Put a space between all curly braces+`prettyprint_spaceEmptyParens` | Put a space between empty parentheses (e.g. `( )`). Only applies when `prettyprint_spaceBetweenParens` is set+`prettyprint_spaceEmptyBraces` | Put a space between empty braces (e.g. `{ }`). Only applies when `prettyprint_spaceBetweenBraces` is set+`prettyprint_spaceAfterLabel` | Put a space after a `::label::` statement+`prettyprint_semicolons` | Clutter the script with semicolons after every damn statement+`prettyprint_cStyle` | Use C style operators and comments everywhere+`prettyprint_indentation` | What to use for indentation. Any string is valid, but some amount of spaces or `"\t"` is recommended+`prettyprint_spaceBeforeComma` | Whether to place a space before every comma+`prettyprint_spaceAfterComma` | Whether to place a space after every comma+`prettyprint_removeRedundantParens` | Whether to remove unnecessary parentheses (e.g. `x = (1 + 2)`, `if ((1) + (2) == 3) then`)+`prettyprint_minimizeParens` | Removes parentheses which are unnecessary due to operator precedence (e.g. `(1 * 2) + 3`). This option also removes redundant parameters, regardless of whether `prettyprint_removeRedundantParens` is enabled.+`prettyprint_assumeOperatorAssociativity` | Only takes effect when `prettyprint_minimizeParens` is `true`. It decides whether parameters can be removed when the involved operators are assumed associative. Examples: `a * (b * c)`, `a and (b and c)`. This assumption is generally true, except for floating point numbers, where removing parentheses can actually change the outcome of the calculation. See [Stack Overflow](https://stackoverflow.com/a/10371890). This option is set to `true` by default, because the expectation is that this will not be problematic even if it affects your code. In a very rare case, this might cause trouble, though. You might want to consider turning this off if you have floating point code that heavily relies on evaluation order. You may also choose to leave this option on and ensure evaluation order by explicitly setting variables.+`prettyprint_rejectInvalidCode` | Whether not to pretty print when the code is syntactically invalid++### Other options++- `log_format`: Decides how to format linter warnings and error messages. Possible values are `"auto"`, `"standard"` and `"github"`. The `"github"` output format is specifically designed for usage with GitHub actions. The default value is `"auto"`, With `"auto"`, the log format will be `"github"` when the environment variables `GITHUB_ACTIONS` and `GITHUB_WORKFLOW` are both present, and `"standard"` otherwise.++## Editor Plugins++Through community support, GLuaFixer is supported across a wide variety of popular editors.++Here's a list of plugins we recommend (PRs for more tools welcome!):++### Sublime++- <https://github.com/FPtje/SublimeLinter-contrib-glualint>++### Atom++- <https://github.com/FPtje/linter-glualint>++### VS Code++- [vscode-glualint](https://marketplace.visualstudio.com/items?itemName=goz3rr.vscode-glualint)+- [GLua Enhanced](https://marketplace.visualstudio.com/items?itemName=venner.vscode-glua-enhanced)++### Vim++- <https://github.com/CFC-Servers/gluafixer.vim>++## Reusable Workflow++You can easily run GLuaFixer in your own Workflows using the included Reusable Workflow.++### Setup++To run GLuaFixer on all of your PRs, create a new file in your repository: `.github/workflows/glualint.yml` with the following contents:++```yml+name: GLuaFixer++on:+  pull_request:++jobs:+  Lint:+    uses: FPtje/GLuaFixer/.github/workflows/glualint.yml@master+```++Now, every time you make or update a PR, GLuaFixer will run and report any linting violations right on your PR!++### Configuration++The GLuaFixer Workflow can be configured, too.++You have two options for configuration:++- Include a file in your repository containing the GLuaFixer config+- Upload your GLuaFixer config somewhere (gist.github.com, pastebin/hastebin, etc.)++Then, modify your Workflow like so:++```yml+name: GLuaLint++on:+  pull_request:++jobs:+  Lint:+    uses: FPtje/GLuaFixer/.github/workflows/glualint.yml@master+    with:+      config: "<link or relative path to config file>"+```
+ app/GLuaFixer/Cli.hs view
@@ -0,0 +1,224 @@+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE GeneralisedNewtypeDeriving #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedRecordDot #-}++-- | CLI interface of the glualint executable+module GLuaFixer.Cli (SettingsPath (..), Options (..), Command (..), OverriddenSettings (..), overrideSettings, runParse, legacyCliParser) where++import Control.Applicative ((<**>), (<|>))+import Data.Maybe (fromMaybe)+import GLuaFixer.LintMessage (LogFormat (..), LogFormatChoice (..))+import GLuaFixer.LintSettings (Indentation (..), LintSettings (..), StdInOrFiles (..))+import Options.Applicative (optional)+import qualified Options.Applicative as Opt++newtype SettingsPath = SettingsPath FilePath+  deriving newtype Show++-- | Command line options of glualint+data Options = Options+  { optsConfigFile :: Maybe SettingsPath+  , optsOverridden :: OverriddenSettings+  , optsCommand :: Command+  , optsFiles :: StdInOrFiles+  , optsDebug :: Bool+  } deriving (Show)++-- | Available subcommands+data Command+  = Lint+  | PrettyPrint+  | AnalyseGlobals+  | DumpAst+  | Test+  | PrintVersion+  deriving (Show)++-- | Settings in the config file that can be overridden through the command line.+data OverriddenSettings = OverriddenSettings+  { indentation :: Maybe Indentation+  , outputFormat :: Maybe LogFormatChoice+  } deriving Show++-- | Override settings with the options passed on the command line+overrideSettings :: OverriddenSettings -> LintSettings -> LintSettings+overrideSettings overridden settings =+  settings+    { prettyprint_indentation =+        maybe settings.prettyprint_indentation unIndentation overridden.indentation+    , log_format = fromMaybe settings.log_format overridden.outputFormat+    }++-- | Run the parser against arguments+runParse :: [String] -> Opt.ParserResult Options+runParse = Opt.execParserPure cliPreferences cliParserInfo++-- | Preferences passed to optparse-applicative+cliPreferences :: Opt.ParserPrefs+cliPreferences = Opt.defaultPrefs{Opt.prefShowHelpOnEmpty = True}++-- | Metadata of the application+cliParserInfo :: Opt.ParserInfo Options+cliParserInfo =+  Opt.info+    (cliParser <**> Opt.helper)+    ( Opt.fullDesc+        <> Opt.progDesc "Linter and pretty printer for Garry's mod's flavour of Lua."+        <> Opt.header "glualint - lint and pretty print GLua files."+    )++-- | Defines the command line interface parser+cliParser :: Opt.Parser Options+cliParser =+  Options+    <$> configOption+    <*> (OverriddenSettings <$> indentOption <*> outputFormatOption)+    <*> commandParser+    <*> parseStdInOrFiles+    <*> parseDebug+ where+  configOption :: Opt.Parser (Maybe SettingsPath)+  configOption =+    optional $+      SettingsPath+        <$> Opt.strOption+          ( Opt.long "config"+              <> Opt.metavar "PATH"+              <> Opt.help "Explicitly define config file location. By default it will search for it."+          )++  indentOption :: Opt.Parser (Maybe Indentation)+  indentOption =+    optional $+      Opt.strOption+        ( Opt.long "indentation"+            <> Opt.metavar "STR"+            <> Opt.help "What to use for indentation when pretty printing, 4 spaces by default."+        )++  outputFormatOption :: Opt.Parser (Maybe LogFormatChoice)+  outputFormatOption =+    optional $+      Opt.option+        outputFormatReader+        ( Opt.long "output-format"+            <> Opt.metavar "FORMAT"+            <> Opt.help "Logging format, either 'auto', 'standard' or 'github', defaults to 'standard'"+        )++  outputFormatReader :: Opt.ReadM LogFormatChoice+  outputFormatReader = Opt.eitherReader $ \case+    "standard" -> Right $ LogFormatChoice StandardLogFormat+    "github" -> Right $ LogFormatChoice GithubLogFormat+    "auto" -> Right AutoLogFormatChoice+    val -> Left $ "Bad output format '" <> val <> "', must be either 'auto', 'standard' or 'github'."++  parseDebug :: Opt.Parser Bool+  parseDebug =+      Opt.switch+        ( Opt.long "debug"+            <> Opt.help "Whether to enable some debug prints."+        )++  commandParser :: Opt.Parser Command+  commandParser =+    Opt.hsubparser+      ( Opt.command+          "lint"+          ( Opt.info (pure Lint) $+              Opt.progDesc "Lint the given files. Directories will be traversed recursively."+          )+          <> Opt.command+            "pretty-print"+            ( Opt.info (pure PrettyPrint) $+                Opt.progDesc "Pretty print the given files, replacing their contents with the pretty printed code."+            )+          <> Opt.command+            "analyse-globals"+            ( Opt.info (pure AnalyseGlobals) $+                Opt.progDesc "Print a list of all globals used and defined in the given files/directories."+            )+          <> Opt.command+            "dump-ast"+            ( Opt.info (pure DumpAst) $+                Opt.progDesc "Print a list of all globals used and defined in the given files/directories."+            )+          <> Opt.command+            "test"+            ( Opt.info (pure Test) $+                Opt.progDesc "Run tests on the given files. Use for testing/debugging glualint."+            )+          <> Opt.command+            "version"+            ( Opt.info (pure PrintVersion) $+                Opt.progDesc "Print the version of glualint and exit."+            )+      )++  parseStdInOrFiles :: Opt.Parser StdInOrFiles+  parseStdInOrFiles =+    Opt.flag'+      UseStdIn+      ( Opt.long "stdin"+          <> Opt.help "Use stdin instead of files."+      )+      <|> UseFiles <$> filesArgument++  filesArgument :: Opt.Parser [FilePath]+  filesArgument = Opt.many (Opt.argument Opt.str $ Opt.metavar "FILES")++--+-- Legacy+--++{- | Deprecated and naive command line interface, kept in place for backwards+compatibility.+-}+legacyCliParser :: [String] -> Maybe Options+legacyCliParser args = case go False emptyOptions args of+  (False, _) -> Nothing+  (True, opts@Options{optsCommand = Lint, optsFiles = files}) -> case files of+    UseFiles [] -> Nothing+    _ -> Just opts+  (True, opts) -> Just opts+ where+  emptyOptions =+    Options+      { optsConfigFile = Nothing+      , optsOverridden = OverriddenSettings Nothing Nothing+      , optsCommand = Lint+      , optsFiles = UseFiles []+      , optsDebug = False+      }++  go hasSuccessfulParse options = \case+    ["--config"] -> (False, options)+    -- fail when a subcommand of the new parser is given as argument+    "lint" : _ -> (False, options)+    "pretty-print" : _ -> (False, options)+    "analyse-globals" : _ -> (False, options)+    "dump-ast" : _ -> (False, options)+    "test" : _ -> (False, options)+    "version" : _ -> (False, options)+    "--bash-completion-script" : _ -> (False, options)+    "--fish-completion-script" : _ -> (False, options)+    "--zsh-completion-script" : _ -> (False, options)+    -- End of recursion case+    [] -> (hasSuccessfulParse, options)+    "--debug" : xs -> go True options{optsDebug = True} xs+    "--pretty-print-files" : xs -> go True options{optsCommand = PrettyPrint} xs+    "--pretty-print" : xs -> go True options{optsCommand = PrettyPrint, optsFiles = UseStdIn} xs+    "--analyse-globals" : xs -> go True options{optsCommand = AnalyseGlobals} xs+    "--dump-ast" : xs -> go True options{optsCommand = DumpAst} xs+    "--version" : xs -> go True options{optsCommand = PrintVersion} xs+    "--test" : xs -> go True options{optsCommand = Test} xs+    "--stdin" : xs -> go True options{optsFiles = UseStdIn} xs+    "--config" : f : xs -> go True options{optsConfigFile = Just $ SettingsPath f} xs+    ('-' : '-' : 'i' : 'n' : 'd' : 'e' : 'n' : 't' : 'a' : 't' : 'i' : 'o' : 'n' : '=' : '\'' : ind') : xs ->+      go True options{optsOverridden = options.optsOverridden{indentation = Just $ Indentation ind'}} xs+    ('-' : '-' : 'i' : 'n' : 'd' : 'e' : 'n' : 't' : 'a' : 't' : 'i' : 'o' : 'n' : '=' : ind') : xs ->+      go True options{optsOverridden = options.optsOverridden{indentation = Just $ Indentation ind'}} xs+    f : xs -> case optsFiles options of+      UseStdIn -> go True options{optsFiles = UseFiles [f]} xs+      UseFiles fs -> go True options{optsFiles = UseFiles $ f : fs} xs
+ app/GLuaFixer/Effects/AnalyseGlobals.hs view
@@ -0,0 +1,74 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE OverloadedRecordDot #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}++module GLuaFixer.Effects.AnalyseGlobals where++import Data.Char (toLower)+import Data.Map.Strict (Map)+import qualified Data.Map.Strict as Map+import Effectful (Eff, (:>))+import qualified Effectful.State.Static.Local as State+import GHC.Exts (sortWith)+import GLua.AG.AST (AST)+import GLua.AG.PrettyPrint (renderRegion)+import GLua.AG.Token (Region)+import GLuaFixer.AG.ASTLint (globalDefinitions)+import GLuaFixer.Effects.Logging (Logging, putStrLnStdOut)+import GLuaFixer.LintSettings (LintSettings)+import Prelude hiding (readFile, writeFile)++data VariableLocation = VariableLocation+  { file :: !FilePath+  , regions :: ![Region]+  }+newtype AnalysisState = AnalysisState {state :: Map String [VariableLocation]}++emptyState :: AnalysisState+emptyState = AnalysisState Map.empty++-- | Run the analysis and get the finished analysis state+execAnalysis :: Eff (State.State AnalysisState : es) () -> Eff es AnalysisState+execAnalysis = State.execState emptyState++-- | Analyse a single file+analyseFile :: (State.State AnalysisState :> es) => LintSettings -> FilePath -> AST -> Eff es ()+analyseFile lintSettings filepath ast = do+  let+    definitionsInFile :: Map String [Region] = globalDefinitions lintSettings ast+    variableLocations :: Map String [VariableLocation] =+      Map.map ((: []) . VariableLocation filepath) definitionsInFile++  State.modify $ \analysisState ->+    AnalysisState $ Map.unionWith (++) analysisState.state variableLocations++{- | Print the analysis state to the terminal.+TODO: make the rendering a pure function+-}+reportAnalysis :: forall es. (Logging :> es) => AnalysisState -> Eff es ()+reportAnalysis analysis =+  mapM_ reportGlobal globals+ where+  globals :: [(String, [VariableLocation])]+  globals = sortWith (map toLower . fst) $ Map.toList $ Map.map (sortWith file) analysis.state++  reportRegions :: [Region] -> Eff es ()+  reportRegions rgs =+    mapM_ (\r -> putStrLnStdOut $ "    " ++ renderRegion r) $ reverse rgs++  reportVariableLocation :: VariableLocation -> Eff es ()+  reportVariableLocation location =+    do+      putStrLnStdOut $ "  " ++ file location ++ ":"+      reportRegions $ regions location+      putStrLnStdOut ""++  reportGlobal :: (String, [VariableLocation]) -> Eff es ()+  reportGlobal (global, analyses) =+    do+      putStrLnStdOut $ "- " ++ global+      mapM_ reportVariableLocation analyses
+ app/GLuaFixer/Effects/Cli.hs view
@@ -0,0 +1,66 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}++module GLuaFixer.Effects.Cli where++import Effectful (Dispatch (Static), DispatchOf, Eff, Effect, IOE, (:>))+import Effectful.Dispatch.Static (SideEffects (WithSideEffects), StaticRep, evalStaticRep, unsafeEff_)+import qualified Effectful.Environment as Eff+import GHC.IO.Exception (ExitCode (..))+import GLuaFixer.Cli (Options, legacyCliParser, runParse)+import qualified Options.Applicative as Opt+import qualified Options.Applicative.Help.Types as Opt++-- | Effect for parsing the CLI arguments.+data Cli :: Effect++type instance DispatchOf Cli = Static WithSideEffects++data instance StaticRep Cli = Cli++-- | Run the Cli effect+runCliIO :: IOE :> es => Eff (Cli : es) a -> Eff es a+runCliIO = evalStaticRep Cli++{- | The result of parsing the CLI arguments. Either successful, with Options describing the running+parameters of glualint, or alternatively, show the help text and exit with the exit code+-}+data CliParseResult+  = ParseSuccessful Options+  | PrintHelpText ExitCode String++-- | Parse the CLI options+parseCliOptions :: (Eff.Environment :> es, Cli :> es) => Eff es CliParseResult+parseCliOptions = do+  args <- Eff.getArgs++  case runParse args of+    Opt.Success options -> pure $ ParseSuccessful options+    Opt.CompletionInvoked completionResult -> do+      progName <- Eff.getProgName+      helpText <- execCompletion completionResult progName+      pure $ PrintHelpText ExitSuccess helpText+    Opt.Failure parserFailure -> do+      progName <- Eff.getProgName+      let+        (parserHelp, exitCode, terminalColumns) = Opt.execFailure parserFailure progName++      let printHelpText = PrintHelpText exitCode $ Opt.renderHelp terminalColumns parserHelp+      case exitCode of+        -- This means the help was activated. Print the help+        ExitSuccess ->+          pure printHelpText+        ExitFailure _ ->+          -- Attempt legacy CLI interface+          case legacyCliParser args of+            Just options -> pure $ ParseSuccessful options+            Nothing -> pure printHelpText++-- | Calculate the autocomplete string+execCompletion :: Cli :> es => Opt.CompletionResult -> String -> Eff es String+execCompletion cmpletionResult progName =+  unsafeEff_ $ Opt.execCompletion cmpletionResult progName
+ app/GLuaFixer/Effects/Files.hs view
@@ -0,0 +1,195 @@+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedRecordDot #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}++module GLuaFixer.Effects.Files where++import Control.DeepSeq (deepseq, force)+import Control.Monad.IO.Class (liftIO)+import Data.List (foldl', stripPrefix)+import Data.Maybe (fromMaybe, listToMaybe, mapMaybe)+import Effectful (Dispatch (Dynamic), DispatchOf, Eff, Effect, IOE, (:>))+import Effectful.Dispatch.Dynamic (interpret, send, interpose)+import Effectful.Dispatch.Static (HasCallStack)+import qualified System.Directory as Dir+import System.FilePath (takeDirectory, (</>))+import System.FilePath.Find (FindClause, always, fileName, filePath, find, (&&?), (/~?), (~~?))+import System.FilePath.GlobPattern (GlobPattern)+import System.IO (IOMode (..), hGetContents, hPutStrLn, hSetEncoding, utf8_bom, withFile)+import Prelude hiding (readFile, writeFile)+import GLuaFixer.Effects.Logging (Logging, putStrLnStdError)++newtype Directory = Directory {dir :: FilePath}+newtype FileNames = FileNames {names :: [String]}+newtype IgnoreFiles = IgnoreFiles {ignore :: [GlobPattern]}++-- | Interacting with the file system+data Files :: Effect where+  -- | Get current working directory alias+  GetCurrentDirectory :: Files m FilePath+  -- | Read stdin+  ReadStdIn :: Files m String+  -- | Read a file+  ReadFile :: FilePath -> Files m String+  -- | Write to a file+  WriteFile :: FilePath -> String -> Files m ()+  -- | Returns whether a file exists+  FileExists :: FilePath -> Files m Bool+  -- | Returns whether a file exists and is a directory+  IsDirectory :: FilePath -> Files m Bool+  -- | Will search upwards in directories for a file, returning it if it exists+  SearchUpwardsForFile :: Directory -> FileNames -> Files m (Maybe FilePath)+  -- | Returns the file path of the first path that exists+  FirstExists :: [FilePath] -> Files m (Maybe FilePath)+  -- | Search for Lua files+  FindLuaFiles :: IgnoreFiles -> FilePath -> Files m [FilePath]+  -- | Get Home directory+  GetHomeDirectory :: Files m FilePath+  -- | Make a path absolute+  MakeAbsolute :: FilePath -> Files m FilePath++type instance DispatchOf Files = Dynamic++makeAbsolute :: (Files :> es) => FilePath -> Eff es FilePath+makeAbsolute filepath = send $ MakeAbsolute filepath++getHomeDirectory :: Files :> es => Eff es FilePath+getHomeDirectory = send GetHomeDirectory++findLuaFiles :: Files :> es => IgnoreFiles -> FilePath -> Eff es [FilePath]+findLuaFiles ignoreFiles filepath+  = send $ FindLuaFiles ignoreFiles filepath++firstExists :: Files :> es => [FilePath] -> Eff es (Maybe FilePath)+firstExists files = send $ FirstExists files++searchUpwardsForFile :: Files :> es => Directory -> FileNames -> Eff es (Maybe FilePath)+searchUpwardsForFile directory files = send $ SearchUpwardsForFile directory files++isDirectory :: Files :> es => FilePath -> Eff es Bool+isDirectory filepath = send $ IsDirectory filepath++fileExists :: Files :> es => FilePath -> Eff es Bool+fileExists filepath = send $ FileExists  filepath++writeFile :: Files :> es => FilePath -> String -> Eff es ()+writeFile filepath contents = send $ WriteFile filepath contents++readFile :: Files :> es => FilePath -> Eff es String+readFile filepath = send $ ReadFile filepath++readStdIn :: Files :> es => Eff es String+readStdIn = send ReadStdIn++getCurrentDirectory ::+  forall (es_a9miX :: [Effect]). (HasCallStack, Files :> es_a9miX) =>+                                 Eff es_a9miX FilePath+getCurrentDirectory = send (GetCurrentDirectory @(Eff es_a9miX))++runFilesIO :: forall es a. (IOE :> es) => Eff (Files : es) a -> Eff es a+runFilesIO = interpret $ \_ -> \case+  GetCurrentDirectory -> liftIO Dir.getCurrentDirectory+  ReadStdIn -> liftIO getContents+  ReadFile file -> liftIO $ do+    withFile file ReadMode $ \handle -> do+      hSetEncoding handle utf8_bom+      !contents <- force <$> hGetContents handle+      pure contents+  WriteFile file contents -> deepseq contents $+    liftIO $+      withFile file WriteMode $ \handle -> do+        hSetEncoding handle utf8_bom+        hPutStrLn handle contents+  FileExists filepath -> liftIO $ Dir.doesFileExist filepath+  IsDirectory filepath -> liftIO $ Dir.doesDirectoryExist filepath+  SearchUpwardsForFile (Directory directory) (FileNames filename) ->+    let+      go !subdir = do+        let filepaths = fmap (subdir </>) filename+        mbFoundFile <- runFilesIO $ firstExists filepaths+        case mbFoundFile of+          Just file -> pure $ Just file+          Nothing -> do+            let up = takeDirectory subdir+            dirExists <- runFilesIO $ isDirectory up+            if up == subdir || not dirExists+              then pure Nothing+              else go up+     in+      go directory+  FirstExists filepath -> case filepath of+    (file : files) -> do+      exists <- runFilesIO $ fileExists file+      if exists+        then pure $ Just file+        else runFilesIO $ firstExists files+    [] -> pure Nothing+  FindLuaFiles (IgnoreFiles ignoreFiles) path ->+    let+      ignoredGlobs = foldl' (&&?) always $ map (relativeFilePath /~?) ignoreFiles++      relativeFilePath :: FindClause FilePath+      relativeFilePath = fmap stripFromPath filePath++      -- Turn absolute path into relative path by stripping prefix+      stripFromPath :: FilePath -> FilePath+      stripFromPath fp =+        fromMaybe fp $ listToMaybe $ mapMaybe (`stripPrefix` fp) pathsToStrip++      -- Prefixes to attempt to strip, in order+      pathsToStrip =+        [ "./"+        , path ++ "/"+        , path+        ]+     in+      liftIO $ find always (fileName ~~? "*.lua" &&? ignoredGlobs) path+  GetHomeDirectory -> liftIO Dir.getHomeDirectory+  MakeAbsolute filepath -> liftIO $ Dir.makeAbsolute filepath++-- | Trace actions on files, useful for debugging+traceFiles :: (Files :> es, Logging :> es) => Eff es a -> Eff es a+traceFiles = interpose $ \_ -> \case+  GetCurrentDirectory -> do+    putStrLnStdError "GetCurrentDirectory"+    send GetCurrentDirectory+  ReadStdIn -> do+    putStrLnStdError "ReadStdIn"+    send ReadStdIn+  ReadFile filepath -> do+    putStrLnStdError $ "ReadFile " <> filepath+    send $ ReadFile filepath+  WriteFile filepath contents -> do+    putStrLnStdError $ "WriteFile " <> filepath+    send $ WriteFile  filepath contents+  FileExists filepath -> do+    putStrLnStdError "FileExists"+    send $ FileExists filepath+  IsDirectory filepath -> do+    putStrLnStdError $ "IsDirectory " <> filepath+    send $ IsDirectory filepath+  SearchUpwardsForFile directory filenames -> do+    putStrLnStdError $ "SearchUpwardsForFile " <> directory.dir <> " " <> show filenames.names+    send $ SearchUpwardsForFile directory filenames+  FirstExists filepath -> do+    putStrLnStdError $ "FirstExists " <> show filepath+    send $ FirstExists filepath+  FindLuaFiles ignores filepath -> do+    putStrLnStdError $ "FindLuaFiles " <> show ignores.ignore <> " " <> filepath+    send $ FindLuaFiles ignores filepath+  GetHomeDirectory -> do+    putStrLnStdError "GetHomeDirectory"+    send GetHomeDirectory+  MakeAbsolute filepath -> do+    putStrLnStdError $ "MakeAbsolute " <> filepath+    send $ MakeAbsolute filepath++traceFilesIfEnabled :: (Files :> es, Logging :> es) => Bool -> Eff es a -> Eff es a+traceFilesIfEnabled enabled = if enabled then traceFiles else id
+ app/GLuaFixer/Effects/Interruptible.hs view
@@ -0,0 +1,61 @@+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}++module GLuaFixer.Effects.Interruptible where++import Data.IORef (IORef, atomicWriteIORef, newIORef, readIORef)+import Effectful (Dispatch (Static), DispatchOf, Eff, Effect, IOE, (:>))+import Effectful.Dispatch.Static (SideEffects (WithSideEffects), StaticRep, evalStaticRep, getStaticRep, unsafeEff_)+import qualified System.Signal as Signal++-- | Effect for allowing graceful interruptions. Interruptions are polled, so they can be ignored.+data Interruptible :: Effect++type instance DispatchOf Interruptible = Static WithSideEffects++newtype instance StaticRep Interruptible = Interruptible (IORef Bool)++-- | Run an interruptible in IO, installs signal handlers to take care of the interrupting+runInterruptible :: IOE :> es => Eff (Interruptible : es) a -> Eff es a+runInterruptible m = do+  aborted <- unsafeEff_ $ newIORef False+  unsafeEff_ $ do+    Signal.installHandler Signal.sigTERM $ \_ -> atomicWriteIORef aborted True+    Signal.installHandler Signal.sigINT $ \_ -> atomicWriteIORef aborted True++  evalStaticRep (Interruptible aborted) m++-- | Interrupt the computation+interrupt :: Interruptible :> es => Eff es ()+interrupt = do+  Interruptible aborted <- getStaticRep+  unsafeEff_ $ atomicWriteIORef aborted True++-- | Returns whether an interrupt has been sent+hasBeenInterrupted :: Interruptible :> es => Eff es Bool+hasBeenInterrupted = do+  Interruptible aborted <- getStaticRep+  unsafeEff_ $ readIORef aborted++-- | Strict interruptible fold+interruptibleFoldMStrict ::+  Interruptible :> es =>+  (a -> b -> Eff es a) ->+  a ->+  [b] ->+  Eff es a+interruptibleFoldMStrict f a = \case+  [] -> pure a+  (x : xs) -> do+    weDone <- hasBeenInterrupted+    if weDone then+      pure a+    else do+      !res <- f a x+      interruptibleFoldMStrict f res xs
+ app/GLuaFixer/Effects/Logging.hs view
@@ -0,0 +1,82 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}++module GLuaFixer.Effects.Logging where++import Control.Monad.IO.Class (liftIO)+import Data.Maybe (isJust)+import Effectful (Dispatch (Dynamic), DispatchOf, Eff, Effect, IOE, (:>))+import Effectful.Dispatch.Dynamic (interpret, send)+import qualified Effectful.Environment as Env+import GLuaFixer.LintMessage (LintMessage, LogFormat (..), LogFormatChoice (..), formatLintMessage)+import System.IO (hPutStrLn, stderr)++-- | The effect for emitting lint messages to the right channel+data Logging :: Effect where+  -- | Emit a single lint message in the given format+  EmitLintMessage :: LogFormat -> LintMessage -> Logging m ()+  -- | Find out which logging format to use+  GetLogFormat :: LogFormatChoice -> Logging m LogFormat+  -- | Print a string in stdout+  PutStrLnStdOut :: String -> Logging m ()+  -- | Print a string in stdout+  PutStrStdOut :: String -> Logging m ()+  -- | Print a string in stderr+  PutStrLnStdError :: String -> Logging m ()++type instance DispatchOf Logging = Dynamic++putStrLnStdError :: Logging :> es => String -> Eff es ()+putStrLnStdError str = send $ PutStrLnStdError str++putStrStdOut :: Logging :> es => String -> Eff es ()+putStrStdOut str = send $ PutStrStdOut str++putStrLnStdOut :: Logging :> es => String -> Eff es ()+putStrLnStdOut str = send $ PutStrLnStdOut str++getLogFormat :: Logging :> es => LogFormatChoice -> Eff es LogFormat+getLogFormat logFormatChoice = send $ GetLogFormat logFormatChoice++emitLintMessage :: Logging :> es => LogFormat -> LintMessage -> Eff es ()+emitLintMessage logFormat lintMessage = send $ EmitLintMessage logFormat lintMessage++-- | Run the logging in IO+runLoggingIO :: (IOE :> es, Env.Environment :> es) => Eff (Logging : es) a -> Eff es a+runLoggingIO = interpret $ \_ -> \case+  EmitLintMessage logFormat lintMessage -> case logFormat of+    StandardLogFormat ->+      liftIO $ putStrLn $ formatLintMessage StandardLogFormat lintMessage+    GithubLogFormat -> do+      liftIO $ putStrLn $ formatLintMessage GithubLogFormat lintMessage+      liftIO $ putStrLn $ formatLintMessage StandardLogFormat lintMessage+  GetLogFormat (LogFormatChoice format) -> pure format+  GetLogFormat AutoLogFormatChoice -> do+    actionsExists <- isJust <$> Env.lookupEnv "GITHUB_ACTIONS"+    workflowExists <- isJust <$> Env.lookupEnv "GITHUB_WORKFLOW"++    pure $+      if actionsExists && workflowExists+        then GithubLogFormat+        else StandardLogFormat+  PutStrLnStdOut str ->+    liftIO $ putStrLn str+  PutStrStdOut str ->+    liftIO $ putStr str+  PutStrLnStdError str ->+    liftIO $ hPutStrLn stderr str++runLoggingPureNoop :: Eff (Logging : es) a -> Eff es a+runLoggingPureNoop = interpret $ \_ -> \case+  EmitLintMessage _ _ -> pure ()+  GetLogFormat (LogFormatChoice format) -> pure format+  GetLogFormat AutoLogFormatChoice -> pure StandardLogFormat+  PutStrLnStdOut _ -> pure ()+  PutStrStdOut _ -> pure ()+  PutStrLnStdError _ -> pure ()
+ app/GLuaFixer/Effects/Run.hs view
@@ -0,0 +1,329 @@+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE OverloadedRecordDot #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}++module GLuaFixer.Effects.Run where++import Control.Monad (unless, when)+import qualified Data.Aeson as JSON+import qualified Data.ByteString.Lazy.Char8 as BL8+import Effectful (Eff, (:>))+import qualified Effectful.Environment as Eff+import GLua.AG.AST (AST)+import GLua.ASTInstances ()+import qualified GLua.PSParser as PSP+import qualified GLua.Parser as UUP+import GLuaFixer.Cli (Command (..), Options (..), OverriddenSettings, SettingsPath)+import GLuaFixer.Effects.Cli (Cli, CliParseResult (..), parseCliOptions)+import GLuaFixer.Effects.Files (Files, IgnoreFiles (..), findLuaFiles, getCurrentDirectory, isDirectory, readFile, readStdIn, writeFile, traceFilesIfEnabled)+import GLuaFixer.Effects.Interruptible (Interruptible, interruptibleFoldMStrict)+import GLuaFixer.Effects.Logging (Logging, emitLintMessage, getLogFormat, putStrLnStdError, putStrLnStdOut, putStrStdOut)+import GLuaFixer.Effects.Settings (Settings, getSettingsForFile, SettingsError (CouldNotParseSettings), runSettings, traceSettingsIfEnabled)+import qualified GLuaFixer.Interface as Interface+import GLuaFixer.LintMessage (sortLintMessages)+import GLuaFixer.LintSettings (+  LintSettings (..),+  StdInOrFiles (..),+ )+import System.Exit (ExitCode (..))+import Prelude hiding (lex, readFile, writeFile)+import GLuaFixer.Effects.AnalyseGlobals (execAnalysis, analyseFile, reportAnalysis)+import Effectful.Error.Static (runErrorNoCallStack)+import GLuaFixer.Version (version)++-- | Top level run function+run :: ( Interruptible :> es+  , Files :> es+  , Logging :> es+  , Eff.Environment :> es+  , Cli :> es+  ) =>+  Eff es ExitCode+run = do+  pareResult <- parseCliOptions++  case pareResult of+    PrintHelpText exitCode helpText -> do+      putStrLnStdError helpText+      pure exitCode+    ParseSuccessful options -> do+      result <- runErrorNoCallStack @SettingsError $+        runSettings $+        runOptions options++      case result of+        Left (CouldNotParseSettings err) -> do+          putStrLnStdError $ "Could not parse settings file: " <> err+          pure $ ExitFailure 1+        Right exitCode -> pure exitCode++-- | Run the given options+runOptions :: ( Interruptible :> es+  , Files :> es+  , Settings :> es+  , Logging :> es+  , Eff.Environment :> es+  , Cli :> es+  ) =>+  Options ->+  Eff es ExitCode+runOptions options =+  traceFilesIfEnabled options.optsDebug $+  traceSettingsIfEnabled options.optsDebug $ do+  when (options.optsDebug) $+    putStrLnStdError $ show options+  case (options.optsCommand, options.optsFiles) of+    (Lint, UseStdIn) -> do+      (lintSettings, contents) <- getStdIn options.optsConfigFile options.optsOverridden+      lint lintSettings "stdin" contents+    (Lint, UseFiles files) ->+      foldLuaFiles+        options.optsConfigFile+        options.optsOverridden+        ExitSuccess+        files+        $ \exitCode lintSettings filepath contents ->+          worstExitCode exitCode <$> lint lintSettings filepath contents+    (PrettyPrint, UseStdIn) -> do+      (lintSettings, contents) <- getStdIn options.optsConfigFile options.optsOverridden+      case prettyprint lintSettings contents of+        Nothing -> pure $ ExitFailure 1+        Just prettyprinted -> do+          putStrStdOut prettyprinted+          pure ExitSuccess+    (PrettyPrint, UseFiles files) ->+      foldLuaFiles+        options.optsConfigFile+        options.optsOverridden+        ExitSuccess+        files+        $ \exitCode lintSettings filepath contents -> do+          putStrLnStdOut $ "Pretty printing " <> filepath+          case prettyprint lintSettings contents of+            Nothing -> pure $ ExitFailure 1+            Just prettyprinted -> do+              writeFile filepath prettyprinted+              pure exitCode+    (AnalyseGlobals, UseStdIn) -> do+      (lintSettings, contents) <- getStdIn options.optsConfigFile options.optsOverridden+      withParsed lintSettings "stdin" contents (ExitFailure 1) $ \ast -> do+        analysis <- execAnalysis $ analyseFile lintSettings "stdin" ast+        reportAnalysis analysis+        pure ExitSuccess+    (AnalyseGlobals, UseFiles files) -> do+      analysis <- execAnalysis $ foldLuaFiles+        options.optsConfigFile+        options.optsOverridden+        ()+        files+        $ \() lintSettings filepath contents -> do+          withParsed lintSettings filepath contents () $ \ast ->+            analyseFile lintSettings filepath ast+      reportAnalysis analysis+      pure ExitSuccess+    (DumpAst, UseStdIn) -> do+      (lintSettings, contents) <- getStdIn options.optsConfigFile options.optsOverridden+      withParsed lintSettings "stdin" contents (ExitFailure 1) $ \ast -> do+        putStrLnStdOut $ BL8.unpack $ JSON.encode ast+        pure ExitSuccess+    (DumpAst, UseFiles files) ->+      foldLuaFiles+        options.optsConfigFile+        options.optsOverridden+        ExitSuccess+        files+        $ \exitCode lintSettings filepath contents ->+          withParsed lintSettings filepath contents (ExitFailure 1) $ \ast -> do+            putStrLnStdOut $ BL8.unpack $ JSON.encode ast+            pure exitCode+    (Test, UseStdIn) -> do+      (lintSettings, contents) <- getStdIn options.optsConfigFile options.optsOverridden+      test lintSettings "stdin" contents+      pure ExitSuccess+    (Test, UseFiles files) -> do+      foldLuaFiles+        options.optsConfigFile+        options.optsOverridden+        ()+        files+        $ \() lintSettings filepath contents ->+          test lintSettings filepath contents+      pure ExitSuccess+    (PrintVersion, _) -> do+      putStrLnStdOut version+      pure ExitSuccess++-- | Retrieves the contents of stdin and the settings that apply.+getStdIn ::+  (Files :> es, Settings :> es) =>+  Maybe SettingsPath ->+  OverriddenSettings ->+  Eff es (LintSettings, String)+getStdIn mbSettingsPath overriddenSettings = do+  cwd <- getCurrentDirectory+  settings <- getSettingsForFile mbSettingsPath overriddenSettings cwd+  code <- readStdIn+  pure (settings, code)++{- | Fold over all the Lua files. Recurses into directories, retrieves settings and passes file+contents to the fold function.+-}+foldLuaFiles ::+  forall es a.+  (Files :> es, Interruptible :> es, Settings :> es) =>+  Maybe SettingsPath ->+  OverriddenSettings ->+  a ->+  [FilePath] ->+  (a -> LintSettings -> FilePath -> String -> Eff es a) ->+  Eff es a+foldLuaFiles mbSettingsPath overriddenSettings initial files f =+  interruptibleFoldMStrict go initial files+ where+  go :: a -> FilePath -> Eff es a+  go acc file = do+    isDir <- isDirectory file+    lintSettings <- getSettingsForFile mbSettingsPath overriddenSettings file+    if isDir+      then do+        let ignoreFiles = IgnoreFiles $ lintSettings.lint_ignoreFiles+        recurseFiles <- findLuaFiles ignoreFiles file+        interruptibleFoldMStrict go acc recurseFiles+      else do+        contents <- readFile file+        f acc lintSettings file contents++-- | Lint a file+lint ::+  (Logging :> es, Eff.Environment :> es) =>+  LintSettings ->+  FilePath ->+  String ->+  Eff es ExitCode+lint lintSettings filepath contents = do+  logFormat <- getLogFormat lintSettings.log_format+  let sourceLint = Interface.sourceLint lintSettings filepath contents+  case Interface.lex lintSettings filepath contents of+    Left msgs -> do+      mapM_ (emitLintMessage logFormat) msgs+      pure $ ExitFailure 1+    Right tokens -> do+      let !lextLint = Interface.lexiconLint filepath lintSettings tokens+      case Interface.parse lintSettings filepath tokens of+        Left msgs -> do+          mapM_ (emitLintMessage logFormat) msgs+          pure $ ExitFailure 1+        Right ast -> do+          let+            astLint = Interface.astLint filepath lintSettings ast+            msgs = sortLintMessages $ sourceLint ++ lextLint ++ astLint+          mapM_ (emitLintMessage logFormat) msgs+          pure $ if null msgs then ExitSuccess else ExitFailure 1++-- | Pretty print a file+prettyprint ::+  LintSettings ->+  String ->+  Maybe String+prettyprint lintSettings contents = do+  if lintSettings.prettyprint_rejectInvalidCode && hasErrors+    then Nothing+    else Just $ Interface.prettyprint lintSettings ast+ where+  (tokens, lexErrors) = Interface.lexUU lintSettings contents+  (ast, parseErrors) = Interface.parseUU tokens+  hasErrors = not (null lexErrors) || not (null parseErrors)++-- | Test glualint itself against a file. TODO: Refactor this into a nicer command+test ::+  (Logging :> es, Eff.Environment :> es) =>+  LintSettings ->+  FilePath ->+  String ->+  Eff es ()+test lintSettings filepath contents = do+  putStrLnStdOut $ "Testing " <> filepath+  let+    (uu_lex, uu_lex_errors) = Interface.lexUU lintSettings contents+    (_uu_ast, uu_parseErrs) = Interface.parseUU uu_lex++  unless (null uu_lex_errors) $ do+    putStrLnStdOut $+      "Errors when trying to lex '"+        ++ filepath+        ++ "' with uu-parsinglib lexer!"+    mapM_ (putStrLnStdOut . show) uu_lex_errors++  unless (null uu_parseErrs) $ do+    putStrLnStdOut $+      "Errors when trying to parse '"+        ++ filepath+        ++ "' with uu-parsinglib parser!"+    mapM_ (putStrLnStdOut . show) uu_parseErrs++  logFormat <- getLogFormat lintSettings.log_format++  case Interface.lex lintSettings filepath contents of+    Left msgs ->+      mapM_ (emitLintMessage logFormat) msgs+    Right tokens ->+      case Interface.parse lintSettings filepath tokens of+        Left msgs -> do+          putStrLnStdOut $+            "Errors when trying to parse '" ++ filepath ++ "' with parsec parser!"+          mapM_ (emitLintMessage logFormat) msgs+        Right ast -> do+          let+            prettyprinted = Interface.prettyprint lintSettings ast+            (_uu_ast_pp, uu_parseErrs_pp) = UUP.parseGLuaFromString prettyprinted++          unless (null uu_parseErrs_pp) $ do+            putStrLnStdOut $+              "Errors when trying to parse '"+                ++ filepath+                ++ "' with uu-parsinglib parser after pretty print!"+            mapM_ (putStrLnStdOut . show) uu_parseErrs_pp++          case PSP.parseGLuaFromString prettyprinted of+            Left err -> do+              putStrLnStdOut $+                "Errors when trying to parse '" ++ filepath ++ "' with parsec parser after pretty print!"++              putStrLnStdOut $ show err+            Right _ast -> pure ()++-- | Function to easily parse a file's contents into an AST. This will log any parse failures and+-- give an AST if it can.+withParsed ::+  (Logging :> es, Eff.Environment :> es) =>+  LintSettings ->+  FilePath ->+  String ->+  a ->+  (AST -> Eff es a) ->+  Eff es a+withParsed lintSettings filepath contents defaultValue f = do+  logFormat <- getLogFormat lintSettings.log_format+  case Interface.lex lintSettings filepath contents of+    Left msgs -> do+      mapM_ (emitLintMessage logFormat) msgs+      pure defaultValue+    Right tokens -> do+      case Interface.parse lintSettings filepath tokens of+        Left msgs -> do+          mapM_ (emitLintMessage logFormat) msgs+          pure defaultValue+        Right ast -> f ast++-- | Takes the worst of the two exit codes.+worstExitCode :: ExitCode -> ExitCode -> ExitCode+worstExitCode e1 e2 = case (e1, e2) of+  (ExitSuccess, ExitSuccess) -> ExitSuccess+  (ExitFailure code, _) -> ExitFailure code+  (_, ExitFailure code) -> ExitFailure code
+ app/GLuaFixer/Effects/Settings.hs view
@@ -0,0 +1,130 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TypeOperators #-}++module GLuaFixer.Effects.Settings where++import Control.Applicative ((<|>))+import qualified Data.Aeson as Aeson+import qualified Data.ByteString.Char8 as BS8+import Effectful (Dispatch (Dynamic), DispatchOf, Eff, Effect, (:>))+import Effectful.Dispatch.Dynamic (interpret, send, interpose)+import qualified Effectful.Error.Static as Err+import GLuaFixer.Cli (OverriddenSettings, SettingsPath (..), overrideSettings)+import GLuaFixer.Effects.Files (Files)+import qualified GLuaFixer.Effects.Files as Files+import GLuaFixer.LintSettings (LintSettings, defaultLintSettings)+import System.FilePath (takeDirectory, (</>))+import GLuaFixer.Effects.Logging (Logging, putStrLnStdError)++data Settings :: Effect where+  -- | Search for settings in various locations, returns default settings if nothing is found+  GetSettings :: FilePath -> Settings m LintSettings+  -- | Read settings from a glualint.json file+  SettingsFromFile :: FilePath -> Settings m LintSettings+  -- | Search for settings in a directory, going up until it reaches the root or finds the file+  SearchSettingsInDirectory :: FilePath -> Settings m (Maybe FilePath)+  -- | Search settings in the home directory+  SearchSettingsInHome :: Settings m (Maybe FilePath)++type instance DispatchOf Settings = Dynamic++searchSettingsInHome :: Settings :> es => Eff es (Maybe FilePath)+searchSettingsInHome = send SearchSettingsInHome++searchSettingsInDirectory :: Settings :> es => FilePath -> Eff es (Maybe FilePath)+searchSettingsInDirectory filepath = send $ SearchSettingsInDirectory filepath++settingsFromFile :: Settings :> es => FilePath -> Eff es LintSettings+settingsFromFile filepath = send $ SettingsFromFile filepath++getSettings :: Settings :> es => FilePath -> Eff es LintSettings+getSettings filepath = send $ GetSettings filepath++newtype SettingsError = CouldNotParseSettings String++-- | The default settings file+settingsFile :: FilePath+settingsFile = "glualint.json"++-- | The default settings file when placed in the home folder+homeSettingsFile :: FilePath+homeSettingsFile = ".glualint.json"++-- | Run settings based on the Files effect.+runSettings :: (Files :> es, Err.Error SettingsError :> es) => Eff (Settings : es) a -> Eff es a+runSettings = interpret $ \_ -> \case+  GetSettings filepath -> do+    absolutePath <-+      if filepath == "stdin"+        then Files.getCurrentDirectory+        else Files.makeAbsolute filepath++    fromSearching <- runSettings $ searchSettingsInDirectory absolutePath+    fromHome <- runSettings searchSettingsInHome++    case fromSearching <|> fromHome of+      Just foundSettings -> runSettings $ settingsFromFile foundSettings+      Nothing -> pure defaultLintSettings+  SettingsFromFile filepath -> do+    contents <- Files.readFile filepath+    let+      eDecoded = Aeson.eitherDecodeStrict @LintSettings $ BS8.pack contents++    case eDecoded of+      Left err -> Err.throwError $ CouldNotParseSettings err+      Right decoded -> pure decoded+  SearchSettingsInDirectory filepath -> do+    isDirectory <- Files.isDirectory filepath+    let+      dir = Files.Directory $ if isDirectory then filepath else takeDirectory filepath+      settingsFiles = Files.FileNames [settingsFile, homeSettingsFile]+    Files.searchUpwardsForFile dir settingsFiles+  SearchSettingsInHome -> do+    homeDir <- Files.getHomeDirectory+    let+      fileWithDot = homeDir </> homeSettingsFile+      fileWithoutDot = homeDir </> settingsFile++    Files.firstExists [fileWithDot, fileWithoutDot]++{- | Combines getting the settings from+- An explicitly passed path to a file+- Settings overridden in the CLI+- Settings that apply to a file+-}+getSettingsForFile ::+  Settings :> es =>+  Maybe SettingsPath ->+  OverriddenSettings ->+  FilePath ->+  Eff es LintSettings+getSettingsForFile mbSettingsPath overridden filepath = do+  readSettings <- case mbSettingsPath of+    Just (SettingsPath path) -> settingsFromFile path+    Nothing -> getSettings filepath+  pure $ overrideSettings overridden readSettings++-- | Trace the steps of a settings effect+traceSettings :: (Settings :> es, Logging :> es) => Eff es a -> Eff es a+traceSettings = interpose $ \_ -> \case+  GetSettings filepath -> do+    putStrLnStdError $ "GetSettings " <> filepath+    send $ GetSettings filepath+  SettingsFromFile filepath -> do+    putStrLnStdError $ "SettingsFromFile " <> filepath+    send $ SettingsFromFile filepath+  SearchSettingsInDirectory filepath -> do+    putStrLnStdError $ "SearchSettingsInDirectory " <> filepath+    send $ SearchSettingsInDirectory filepath+  SearchSettingsInHome -> do+    putStrLnStdError "SearchSettingsInHome"+    send SearchSettingsInHome++traceSettingsIfEnabled :: (Settings :> es, Logging :> es) => Bool -> Eff es a -> Eff es a+traceSettingsIfEnabled enabled = if enabled then traceSettings else id
+ app/GLuaFixer/Main.hs view
@@ -0,0 +1,32 @@+module Main where++import GLua.ASTInstances ()++import GHC.IO.Encoding (setLocaleEncoding, utf8)++import Effectful (runEff)+import GLuaFixer.Effects.Run (run)+import qualified Effectful.Environment as Env+import System.Exit (exitWith)+import GLuaFixer.Effects.Cli (runCliIO)+import GLuaFixer.Effects.Files (runFilesIO)+import GLuaFixer.Effects.Interruptible (runInterruptible)+import GLuaFixer.Effects.Logging (runLoggingIO)++main :: IO ()+main = do+  -- Set the encoding of the program to UTF-8. This is to prevent problems when the system's locale+  -- is set to anything but UTF-8.+  -- See https://github.com/FPtje/GLuaFixer/issues/145+  setLocaleEncoding utf8++  exitCode <-+    runEff $+      runCliIO $+      runFilesIO $+      runInterruptible $+      Env.runEnvironment $+      runLoggingIO+      run++  exitWith exitCode
+ app/GLuaFixer/Version.hs view
@@ -0,0 +1,7 @@+module GLuaFixer.Version where++import Data.Version (showVersion)+import qualified Paths_glualint (version)++version :: String+version = showVersion Paths_glualint.version
+ glualint.cabal view
@@ -0,0 +1,110 @@+cabal-version:      3.0+name:               glualint+version:            1.24.6+synopsis:           Attempts to fix your syntax erroring Lua files.+description:+  Linter for Lua, specifically the variant used in Garry's mod.++homepage:           https://github.com/FPtje/GLuaFixer+bug-reports:        https://github.com/FPtje/GLuaFixer/issues+license:            LGPL-2.1-or-later+license-file:       LICENSE+author:             Falco Peijnenburg+maintainer:         fpeijnenburg@gmail.com+copyright:          Falco Peijnenburg+category:           Language+build-type:         Simple+extra-source-files: README.md++source-repository head+  type:     git+  location: git@github.com:FPtje/GLuaFixer.git++library+  default-language: Haskell2010+  build-depends:+    , aeson          >=2        && <3+    , base           >=4.5      && <5+    , bytestring     >=0.11     && <1+    , containers     >=0.6      && <1+    , parsec         >=3        && <4+    , pretty         >=1.1      && <1.2+    , uu-parsinglib  >=2.8      && <3+    , uuagc          >=0.9.40.3 && <0.10+    , uuagc-cabal    >=1.0.3.0  && <2++  hs-source-dirs:   src+  exposed-modules:+    GLua.AG.AST+    GLua.AG.PrettyPrint+    GLua.AG.Token+    GLua.ASTInstances+    GLua.Lexer+    GLua.LineLimitParser+    GLua.Parser+    GLua.PSLexer+    GLua.PSParser+    GLua.TokenTypes+    GLuaFixer.AG.ASTLint+    GLuaFixer.AG.LexLint+    GLuaFixer.BadSequenceFinder+    GLuaFixer.Interface+    GLuaFixer.LintMessage+    GLuaFixer.LintSettings++  ghc-options:      -Wall -fno-warn-unused-do-bind+  other-extensions:+    NoMonomorphismRestriction+    CPP+    FlexibleContexts+    FlexibleInstances+    MultiParamTypeClasses+    Rank2Types+    TypeSynonymInstances++executable glualint+  -- Disable the executable for ghcjs and older versions of ghc. The executable+  -- uses functions only available in ghc 8++  if !impl(ghc >=8.0.0)+    buildable: False++  main-is:          GLuaFixer/Main.hs+  other-modules:+    GLuaFixer.Cli+    GLuaFixer.Effects.AnalyseGlobals+    GLuaFixer.Effects.Cli+    GLuaFixer.Effects.Files+    GLuaFixer.Effects.Interruptible+    GLuaFixer.Effects.Logging+    GLuaFixer.Effects.Run+    GLuaFixer.Effects.Settings+    GLuaFixer.Version+    Paths_glualint++  autogen-modules:  Paths_glualint+  other-extensions:+    NoMonomorphismRestriction+    CPP+    FlexibleContexts+    FlexibleInstances+    MultiParamTypeClasses+    Rank2Types+    TypeSynonymInstances++  build-depends:+    , aeson+    , base+    , bytestring+    , containers+    , deepseq               >=1.4  && <2+    , directory             >=1.3  && <2+    , effectful             >=2.2  && <3+    , filemanip             >=0.3  && <0.4+    , filepath              >=1.4  && <1.5+    , glualint+    , optparse-applicative  >=0.17 && <1+    , signal                >=0.1  && <0.2++  hs-source-dirs:   app+  ghc-options:      -O3 -Wall+  default-language: Haskell2010
+ src/GLua/AG/AST.hs view
@@ -0,0 +1,136 @@+++{-# LANGUAGE DeriveGeneric #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+-- UUAGC 0.9.53.1 (src/GLua/AG/AST.ag)+module GLua.AG.AST where++{-# LINE 10 "src/GLua/AG/AST.ag" #-}++import GLua.AG.Token+import GLua.TokenTypes ()+import GHC.Generics+import Data.Aeson+{-# LINE 15 "src/GLua/AG/AST.hs" #-}+-- AReturn -----------------------------------------------------+data AReturn = AReturn (Region) (MExprList)+             | NoReturn+             deriving ( Generic,Show)+-- AST ---------------------------------------------------------+data AST = AST (([MToken])) (Block)+         deriving ( Generic,Show)+-- Args --------------------------------------------------------+data Args = ListArgs (MExprList)+          | TableArg (FieldList)+          | StringArg (MToken)+          deriving ( Generic,Show)+-- BinOp -------------------------------------------------------+data BinOp = AOr+           | AAnd+           | ALT+           | AGT+           | ALEQ+           | AGEQ+           | ANEq+           | AEq+           | AConcatenate+           | APlus+           | BinMinus+           | AMultiply+           | ADivide+           | AModulus+           | APower+           deriving ( Eq,Generic,Ord,Show)+-- Block -------------------------------------------------------+data Block = Block (MStatList) (AReturn)+           deriving ( Generic,Show)+-- Declaration -------------------------------------------------+type Declaration = ( PrefixExp,MaybeMExpr)+-- Else --------------------------------------------------------+type Else = Maybe (MElse)+-- ElseIf ------------------------------------------------------+type ElseIf = ( MExpr,Block)+-- ElseIfList --------------------------------------------------+type ElseIfList = [MElseIf]+-- Expr --------------------------------------------------------+data Expr = ANil+          | AFalse+          | ATrue+          | ANumber (String)+          | AString (MToken)+          | AVarArg+          | AnonymousFunc (([MToken])) (Block)+          | APrefixExpr (PrefixExp)+          | ATableConstructor (FieldList)+          | BinOpExpr (BinOp) (MExpr) (MExpr)+          | UnOpExpr (UnOp) (MExpr)+          deriving ( Generic,Show)+-- ExprSuffixList ----------------------------------------------+type ExprSuffixList = [PFExprSuffix]+-- Field -------------------------------------------------------+data Field = ExprField (MExpr) (MExpr) (FieldSep)+           | NamedField (MToken) (MExpr) (FieldSep)+           | UnnamedField (MExpr) (FieldSep)+           deriving ( Generic,Show)+-- FieldList ---------------------------------------------------+type FieldList = [Field]+-- FieldSep ----------------------------------------------------+data FieldSep = CommaSep+              | SemicolonSep+              | NoSep+              deriving ( Eq,Generic,Show)+-- FuncName ----------------------------------------------------+data FuncName = FuncName (([MToken])) ((Maybe MToken))+              deriving ( Generic,Show)+-- MElse -------------------------------------------------------+data MElse = MElse (Region) (Block)+           deriving ( Generic,Show)+-- MElseIf -----------------------------------------------------+data MElseIf = MElseIf (Region) (ElseIf)+             deriving ( Generic,Show)+-- MExpr -------------------------------------------------------+data MExpr = MExpr (Region) (Expr)+           deriving ( Generic,Show)+-- MExprList ---------------------------------------------------+type MExprList = [MExpr]+-- MStat -------------------------------------------------------+data MStat = MStat (Region) (Stat)+           deriving ( Generic,Show)+-- MStatList ---------------------------------------------------+type MStatList = [MStat]+-- MaybeMExpr --------------------------------------------------+type MaybeMExpr = Maybe (MExpr)+-- PFExprSuffix ------------------------------------------------+data PFExprSuffix = Call (Args)+                  | MetaCall (MToken) (Args)+                  | ExprIndex (MExpr)+                  | DotIndex (MToken)+                  deriving ( Generic,Show)+-- PrefixExp ---------------------------------------------------+data PrefixExp = PFVar (MToken) (ExprSuffixList)+               | ExprVar (MExpr) (ExprSuffixList)+               deriving ( Generic,Show)+-- Stat --------------------------------------------------------+data Stat = Def (VarsList)+          | LocDef (VarsList)+          | AFuncCall (PrefixExp)+          | ALabel (MToken)+          | ABreak+          | AContinue+          | AGoto (MToken)+          | ADo (Block)+          | AWhile (MExpr) (Block)+          | ARepeat (Block) (MExpr)+          | AIf (MExpr) (Block) (ElseIfList) (Else)+          | ANFor (MToken) (MExpr) (MExpr) (MExpr) (Block)+          | AGFor (([MToken])) (MExprList) (Block)+          | AFunc (FuncName) (([MToken])) (Block)+          | ALocFunc (FuncName) (([MToken])) (Block)+          deriving ( Generic,Show)+-- UnOp --------------------------------------------------------+data UnOp = UnMinus+          | ANot+          | AHash+          deriving ( Generic,Show)+-- VarsList ----------------------------------------------------+type VarsList = [Declaration]
+ src/GLua/AG/PrettyPrint.hs view
@@ -0,0 +1,8039 @@+++{-# LANGUAGE DeriveGeneric #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+-- UUAGC 0.9.53.1 (src/GLua/AG/PrettyPrint.ag)+module GLua.AG.PrettyPrint where++{-# LINE 10 "src/GLua/AG/AST.ag" #-}++import GLua.AG.Token+import GLua.TokenTypes ()+import GHC.Generics+import Data.Aeson+{-# LINE 15 "src/GLua/AG/PrettyPrint.hs" #-}++{-# LINE 4 "src/GLua/AG/PrettyPrint.ag" #-}++import Prelude hiding ((<>))+import Data.List (foldl')+import GLua.AG.AST+import Text.PrettyPrint hiding (parens, brackets, braces)+import GLua.TokenTypes+import Data.Maybe+import Text.Parsec+import Text.Parsec.Error+import Text.ParserCombinators.UU.BasicInstances hiding (pos)+import Debug.Trace+{-# LINE 29 "src/GLua/AG/PrettyPrint.hs" #-}+{-# LINE 19 "src/GLua/AG/PrettyPrint.ag" #-}+++tok :: MToken -> Doc+tok (MToken _ t) = zeroWidthText . show $ t++printList :: (a -> Doc) -> String -> [a] -> Doc+printList _ _ []       = empty+printList f sep' (e : es) = (f e) <> g es+    where+        g []       = empty+        g (e' : es') = zeroWidthText sep' <> (f e') <> g es'++data IsEmpty = IsEmpty | NonEmpty++fromEmpty :: IsEmpty -> Bool+fromEmpty IsEmpty = True+fromEmpty NonEmpty = False++toEmpty :: Bool -> IsEmpty+toEmpty b = if b then IsEmpty else NonEmpty++data PrettyPrintConfig = PPConfig {+    spaceAfterParens :: Bool,+    spaceAfterBrackets :: Bool,+    spaceAfterBraces :: Bool,+    spaceEmptyParens :: Bool,+    spaceEmptyBraces :: Bool,+    spaceAfterLabel :: Bool,+    spaceBeforeComma :: Bool,+    spaceAfterComma :: Bool,+    semicolons :: Bool,+    cStyle :: Bool,+    removeRedundantParens :: Bool,+    minimizeParens :: Bool,+    assumeOperatorAssociativity :: Bool,+    indentation :: String+}++defaultPPConfig :: PrettyPrintConfig+defaultPPConfig = PPConfig {+    spaceAfterParens = False,+    spaceAfterBrackets = False,+    spaceAfterBraces = False,+    spaceEmptyParens = False,+    spaceEmptyBraces = False,+    spaceAfterLabel = False,+    spaceBeforeComma = False,+    spaceAfterComma = True,+    semicolons = False,+    cStyle = False,+    removeRedundantParens = True,+    assumeOperatorAssociativity = True,+    minimizeParens = False,+    indentation = "    "+}++metaDoc :: Maybe MToken -> Doc+metaDoc (Just m) = zchr ':' <> tok m+metaDoc Nothing  = empty++printVarList :: [(PrefixExp, Maybe MExpr)] -> Doc+printVarList vars = printList pp_prefixexp ", " (map fst vars) <-> zchr '=' <-> printList pp_mexpr ", " (catMaybes . map snd $ vars)++printStats :: [MStat] -> Int -> Doc+printStats [] _ = empty+printStats (x : xs) i = nest (i * 4) (pp_mstat x i) $+$ printStats xs i++printElIfs :: [(MExpr, Block)] -> Int -> Doc+printElIfs [] _ = empty+printElIfs ((e, b) : es) i = zeroWidthText "elseif" <-> pp_mexpr e <-> zeroWidthText "then" $+$ pp_block b i $+$ printElIfs es i++printEls :: Maybe Block -> Int -> Doc+printEls Nothing _ = empty+printEls (Just b) i = zeroWidthText "else" $+$ pp_block b i+++renderPos :: LineColPos -> String+renderPos (LineColPos l c _) = "line " ++ show (succ l) ++ ", column " ++ show (succ c)++renderRegion :: Region -> String+renderRegion (Region l r) = renderPos l ++ " - " ++ renderPos r++renderSourcePos :: SourcePos -> String+renderSourcePos sp = "line " ++ (show . succ . sourceLine $ sp) ++ ", column " ++ (show . succ . sourceColumn $ sp)++getMStatPos :: MStat -> String+getMStatPos (MStat p _) = renderRegion p++getAReturnPos :: AReturn -> String+getAReturnPos (AReturn p _) = renderRegion p+getAReturnPos NoReturn = "<unknown>"++getMExprPos :: MExpr -> String+getMExprPos (MExpr p _) = renderRegion p++renderError :: Error LineColPos -> String+renderError (Inserted str pos strs)       = renderPos pos ++ ": Inserted '" ++ str ++ "'." ++ render_expecting strs+renderError (Deleted str pos strs)        = renderPos pos ++ ": Removed '" ++ str ++ "'. " ++render_expecting strs+renderError (Replaced str1 str2 pos strs) = renderPos pos ++ ": Replaced '" ++ str1 ++ "' with '" ++ str2 ++ "' at " ++ renderPos pos ++ render_expecting strs+renderError (DeletedAtEnd str)            = "Deleted '"  ++ str ++ "' at the end of the Lua file because the parser doesn't know what to do with it."++render_expecting :: [String] -> String+render_expecting [a]    = "Parser expected a " ++ a+render_expecting (a:as) = "Parser expected one of [" ++ a ++ concat (map (", " ++) as) ++ "]"+render_expecting []     = "Parser expected nothing"+++renderPSError :: ParseError -> String+renderPSError ps = map replNL . showErrorMessages "or" "unknown parse error" "expecting" "unexpected" "end of input" . errorMessages $ ps+    where+        replNL '\n' = ' '+        replNL c = c++-- | Render comments on multiple lines+renderMLComments :: PrettyPrintConfig -> Int -> [MToken] -> Doc+renderMLComments conf ind toks = foldl' ($+$) empty . map (indent conf ind . tok . convertComment conf) $ toks++-- | Render comments, and prefer having them on a single line. It may not print comments on the same+-- line if that would cause a syntax error (e.g. a multiline comment after a single line comment)+renderSLComments :: PrettyPrintConfig -> Int -> [MToken] -> Doc+renderSLComments conf ind toks = foldl' combine empty . map (convertComment conf) $ toks+    where+        combine :: Doc -> MToken -> Doc+        combine acc mt@(MToken _pos t) =+          case t of+            -- Block comments after single line comments cannot be printed on the same line, as that+            -- would cause a syntax error, e.g. in this case:++            -- foo = { -- single line comment+            -- --[[multiline+            -- comment+            -- ]]+            -- }+            -- Make sure in these cases the comment is printed on a new line, rather than on the+            -- same line+            DashBlockComment _depth comment | '\n' `elem` comment ->+              acc $+$ (indent conf ind $ tok mt)+            SlashBlockComment comment | '\n' `elem` comment ->+              acc $+$ (indent conf ind $ tok mt)+            _ -> acc <-> tok mt++convertComment :: PrettyPrintConfig -> MToken -> MToken+convertComment conf (MToken p t) = MToken p $ convert' t+    where+        convert' :: Token -> Token+        convert' = if cStyle conf then cComment else luaComment++        luaComment :: Token -> Token+        luaComment (SlashComment s) = DashComment s+        luaComment (SlashBlockComment s) = DashBlockComment (lastBracket s) s+        luaComment t' = t'++        -- converting /*]*/ would end up in --[[]]] when plainly converted+        -- Deepen the block comment by 1 if that's the case+        lastBracket :: String -> Int+        lastBracket [] = 0+        lastBracket s = if last s == ']' then 1 else 0++        cComment :: Token -> Token+        cComment (DashComment s) = SlashComment s+        cComment (DashBlockComment _ s) = SlashBlockComment s+        cComment t' = t'++indent :: PrettyPrintConfig -> Int -> Doc -> Doc+indent conf n = (<>) $ zeroWidthText (concat . replicate n $ indentation conf)++parens :: PrettyPrintConfig -> IsEmpty -> Doc -> Doc+parens conf ie doc = zchr '(' `sep'` doc `sep'` zchr ')'+    where+        sep' :: Doc -> Doc -> Doc+        sep' = if spaceAfterParens conf && (not (fromEmpty ie) || spaceEmptyParens conf) then (<->) else (<>)++brackets :: PrettyPrintConfig -> Doc -> Doc+brackets conf doc = zchr '[' `sep'` doc `sep'` zchr ']'+    where+        sep' :: Doc -> Doc -> Doc+        sep' = if spaceAfterBrackets conf then (<->) else (<>)++braces :: PrettyPrintConfig -> IsEmpty -> Doc -> Doc+braces conf ie doc = zchr '{' `sep'` doc `sep'` zchr '}'+    where+        sep' :: Doc -> Doc -> Doc+        sep' = if spaceAfterBraces conf && (not (fromEmpty ie) || spaceEmptyBraces conf) then (<->) else (<>)++-- Zero width char+zchr :: Char -> Doc+zchr c = zeroWidthText [c]++-- Zero width <+>+infixl 6 <->+(<->) :: Doc -> Doc -> Doc+a <-> b | a == empty = b+        | b == empty = a+        | otherwise  = a <> zchr ' ' <> b++-- Operator levels, where level 1 is the lowest level, and level 8 is the highest one+-- See http://www.lua.org/manual/5.2/manual.html#3.4.7+data OperatorLevel+    -- At the top level, there is no assigned operator level yet. This serves as a bottom value.+    = TopLevelExpression+    | OperatorLevel1+    | OperatorLevel2+    | OperatorLevel3+    | OperatorLevel4+    | OperatorLevel5+    | OperatorLevel6+    | OperatorLevel7+    | OperatorLevel8+    deriving (Eq, Ord)+{-# LINE 240 "src/GLua/AG/PrettyPrint.hs" #-}++{-# LINE 754 "src/GLua/AG/PrettyPrint.ag" #-}+++pp_block :: Block -> Int -> Doc+pp_block p i = pretty_Syn_Block (wrap_Block (sem_Block p) (Inh_Block [] i defaultPPConfig emptyRg))++pp_mstat :: MStat -> Int -> Doc+pp_mstat p i = pretty_Syn_MStat (wrap_MStat (sem_MStat p) (Inh_MStat [] i False False defaultPPConfig))++pp_prefixexp :: PrefixExp -> Doc+pp_prefixexp p = pretty_Syn_PrefixExp (wrap_PrefixExp (sem_PrefixExp p) (Inh_PrefixExp [] 0 True TopLevelExpression defaultPPConfig))++pp_pfexprsuffix :: PFExprSuffix -> Doc+pp_pfexprsuffix p = pretty_Syn_PFExprSuffix (wrap_PFExprSuffix (sem_PFExprSuffix p) (Inh_PFExprSuffix [] 0 defaultPPConfig))++pp_field :: Field -> Doc+pp_field p = pretty_Syn_Field (wrap_Field (sem_Field p) (Inh_Field [] 0 defaultPPConfig))++pp_mexpr :: MExpr -> Doc+pp_mexpr p = pretty_Syn_MExpr (wrap_MExpr (sem_MExpr p) (Inh_MExpr [] 0 True TopLevelExpression defaultPPConfig))++prettyprint :: AST -> String+prettyprint p = render $ pretty_Syn_AST (wrap_AST (sem_AST p) (Inh_AST 0 defaultPPConfig))++prettyprintConf :: PrettyPrintConfig -> AST -> String+prettyprintConf conf p = render $ pretty_Syn_AST (wrap_AST (sem_AST p) (Inh_AST 0 conf))++renderBlock        :: Block -> String+renderBlock p      = render $ pretty_Syn_Block (wrap_Block (sem_Block p) (Inh_Block [] 0 defaultPPConfig emptyRg))++renderStat         :: Stat -> String+renderStat p       = render $ pretty_Syn_Stat (wrap_Stat (sem_Stat p) (Inh_Stat [] 0 False False defaultPPConfig emptyRg))++renderMStat         :: MStat -> String+renderMStat p       = render $ pretty_Syn_MStat (wrap_MStat (sem_MStat p) (Inh_MStat [] 0 False False defaultPPConfig))++renderAReturn      :: AReturn -> String+renderAReturn p    = render $ pretty_Syn_AReturn (wrap_AReturn (sem_AReturn p) (Inh_AReturn [] 0 defaultPPConfig))++renderFuncName     :: FuncName -> String+renderFuncName p   = render $ pretty_Syn_FuncName (wrap_FuncName (sem_FuncName p) (Inh_FuncName [] 0 defaultPPConfig))++renderPrefixExp    :: PrefixExp -> String+renderPrefixExp p  = render $ pretty_Syn_PrefixExp (wrap_PrefixExp (sem_PrefixExp p) (Inh_PrefixExp [] 0 True TopLevelExpression defaultPPConfig))++renderExpr         :: Expr -> String+renderExpr p       = render $ pretty_Syn_Expr (wrap_Expr (sem_Expr p) (Inh_Expr [] 0 True TopLevelExpression defaultPPConfig emptyRg))++renderMExpr         :: MExpr -> String+renderMExpr p       = render $ pretty_Syn_MExpr (wrap_MExpr (sem_MExpr p) (Inh_MExpr [] 0 True TopLevelExpression defaultPPConfig))++renderArgs         :: Args -> String+renderArgs p       = render $ pretty_Syn_Args (wrap_Args (sem_Args p) (Inh_Args [] 0 defaultPPConfig))++renderField        :: Field -> String+renderField p      = render $ pretty_Syn_Field (wrap_Field (sem_Field p) (Inh_Field [] 0 defaultPPConfig))++{-# LINE 299 "src/GLua/AG/PrettyPrint.hs" #-}+-- AReturn -----------------------------------------------------+-- cata+sem_AReturn :: AReturn ->+               T_AReturn+sem_AReturn (AReturn _pos _values) =+    (sem_AReturn_AReturn _pos (sem_MExprList _values))+sem_AReturn (NoReturn) =+    (sem_AReturn_NoReturn)+-- semantic domain+type T_AReturn = ([MToken]) ->+                 Int ->+                 PrettyPrintConfig ->+                 ( ([MToken]),AReturn,Bool,Bool,Doc,Int)+data Inh_AReturn = Inh_AReturn {comments_Inh_AReturn :: ([MToken]),indent_Inh_AReturn :: Int,ppconf_Inh_AReturn :: PrettyPrintConfig}+data Syn_AReturn = Syn_AReturn {comments_Syn_AReturn :: ([MToken]),copy_Syn_AReturn :: AReturn,hasBreaking_Syn_AReturn :: Bool,isMultiline_Syn_AReturn :: Bool,pretty_Syn_AReturn :: Doc,statementCount_Syn_AReturn :: Int}+wrap_AReturn :: T_AReturn ->+                Inh_AReturn ->+                Syn_AReturn+wrap_AReturn sem (Inh_AReturn _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpretty,_lhsOstatementCount) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_AReturn _lhsOcomments _lhsOcopy _lhsOhasBreaking _lhsOisMultiline _lhsOpretty _lhsOstatementCount))+sem_AReturn_AReturn :: Region ->+                       T_MExprList ->+                       T_AReturn+sem_AReturn_AReturn pos_ values_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _valuesOcomments :: ([MToken])+              _lhsOcomments :: ([MToken])+              _valuesOisHead :: Bool+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOstatementCount :: Int+              _lhsOcopy :: AReturn+              _valuesOindent :: Int+              _valuesOppconf :: PrettyPrintConfig+              _valuesIcomments :: ([MToken])+              _valuesIcopy :: MExprList+              _valuesIisAssociative :: Bool+              _valuesIisMultiline :: Bool+              _valuesIpos :: Region+              _valuesIprecedence :: OperatorLevel+              _valuesIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 552 "src/GLua/AG/PrettyPrint.ag" #-}+                   _prettyCommentsBefore     $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "return") <-> _valuesIpretty <> _semicolon     <-> _prettyCommentsAfter+                   {-# LINE 348 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _isMultiline =+                  ({-# LINE 553 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valuesIisMultiline+                   {-# LINE 353 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _semicolon =+                  ({-# LINE 554 "src/GLua/AG/PrettyPrint.ag" #-}+                   if semicolons _lhsIppconf then zchr ';' else empty+                   {-# LINE 358 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyCommentsBefore =+                  ({-# LINE 555 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderMLComments _lhsIppconf _lhsIindent (fst _commentsBefore    )+                   {-# LINE 363 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyCommentsAfter =+                  ({-# LINE 556 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter    )+                   {-# LINE 368 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _commentsBefore =+                  ({-# LINE 557 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _isMultiline     then span (\(MToken pos _) -> pos `before` pos_) _lhsIcomments else ([], _lhsIcomments)+                   {-# LINE 373 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _commentsAfter =+                  ({-# LINE 558 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _isMultiline     then span (\(MToken pos _) -> pos `beforeOrOnLine` (rgOr _valuesIpos pos_)) (snd _commentsBefore    ) else ([], snd _commentsBefore    )+                   {-# LINE 378 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valuesOcomments =+                  ({-# LINE 559 "src/GLua/AG/PrettyPrint.ag" #-}+                   snd _commentsAfter+                   {-# LINE 383 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 560 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valuesIcomments+                   {-# LINE 388 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valuesOisHead =+                  ({-# LINE 561 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 393 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 562 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 398 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _isMultiline+                   {-# LINE 403 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOstatementCount =+                  ({-# LINE 287 "src/GLua/AG/PrettyPrint.ag" #-}+                   1+                   {-# LINE 408 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AReturn pos_ _valuesIcopy+                   {-# LINE 413 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 418 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valuesOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 423 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valuesOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 428 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _valuesIcomments,_valuesIcopy,_valuesIisAssociative,_valuesIisMultiline,_valuesIpos,_valuesIprecedence,_valuesIpretty) =+                  values_ _valuesOcomments _valuesOindent _valuesOisHead _valuesOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpretty,_lhsOstatementCount)))+sem_AReturn_NoReturn :: T_AReturn+sem_AReturn_NoReturn =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOstatementCount :: Int+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: AReturn+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 563 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 447 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOstatementCount =+                  ({-# LINE 564 "src/GLua/AG/PrettyPrint.ag" #-}+                   0+                   {-# LINE 452 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 457 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 462 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   NoReturn+                   {-# LINE 467 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 472 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 477 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpretty,_lhsOstatementCount)))+-- AST ---------------------------------------------------------+-- cata+sem_AST :: AST ->+           T_AST+sem_AST (AST _comments _chunk) =+    (sem_AST_AST _comments (sem_Block _chunk))+-- semantic domain+type T_AST = Int ->+             PrettyPrintConfig ->+             ( AST,Bool,Doc)+data Inh_AST = Inh_AST {indent_Inh_AST :: Int,ppconf_Inh_AST :: PrettyPrintConfig}+data Syn_AST = Syn_AST {copy_Syn_AST :: AST,isMultiline_Syn_AST :: Bool,pretty_Syn_AST :: Doc}+wrap_AST :: T_AST ->+            Inh_AST ->+            Syn_AST+wrap_AST sem (Inh_AST _lhsIindent _lhsIppconf) =+    (let ( _lhsOcopy,_lhsOisMultiline,_lhsOpretty) = sem _lhsIindent _lhsIppconf+     in  (Syn_AST _lhsOcopy _lhsOisMultiline _lhsOpretty))+sem_AST_AST :: ([MToken]) ->+               T_Block ->+               T_AST+sem_AST_AST comments_ chunk_ =+    (\ _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _chunkOcomments :: ([MToken])+              _chunkOstatRegion :: Region+              _lhsOisMultiline :: Bool+              _lhsOcopy :: AST+              _chunkOindent :: Int+              _chunkOppconf :: PrettyPrintConfig+              _chunkIcomments :: ([MToken])+              _chunkIcopy :: Block+              _chunkIhasBreaking :: Bool+              _chunkIisMultiline :: Bool+              _chunkIpretty :: Doc+              _chunkIstatementCount :: Int+              _lhsOpretty =+                  ({-# LINE 460 "src/GLua/AG/PrettyPrint.ag" #-}+                   _chunkIpretty $+$ _prettyComments+                   {-# LINE 520 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyComments =+                  ({-# LINE 461 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderMLComments _lhsIppconf _lhsIindent _chunkIcomments+                   {-# LINE 525 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _chunkOcomments =+                  ({-# LINE 462 "src/GLua/AG/PrettyPrint.ag" #-}+                   comments_+                   {-# LINE 530 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _chunkOstatRegion =+                  ({-# LINE 463 "src/GLua/AG/PrettyPrint.ag" #-}+                   emptyRg+                   {-# LINE 535 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _chunkIisMultiline+                   {-# LINE 540 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AST comments_ _chunkIcopy+                   {-# LINE 545 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 550 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _chunkOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 555 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _chunkOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 560 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _chunkIcomments,_chunkIcopy,_chunkIhasBreaking,_chunkIisMultiline,_chunkIpretty,_chunkIstatementCount) =+                  chunk_ _chunkOcomments _chunkOindent _chunkOppconf _chunkOstatRegion+          in  ( _lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+-- Args --------------------------------------------------------+-- cata+sem_Args :: Args ->+            T_Args+sem_Args (ListArgs _args) =+    (sem_Args_ListArgs (sem_MExprList _args))+sem_Args (TableArg _arg) =+    (sem_Args_TableArg (sem_FieldList _arg))+sem_Args (StringArg _arg) =+    (sem_Args_StringArg _arg)+-- semantic domain+type T_Args = ([MToken]) ->+              Int ->+              PrettyPrintConfig ->+              ( ([MToken]),Args,Bool,Doc)+data Inh_Args = Inh_Args {comments_Inh_Args :: ([MToken]),indent_Inh_Args :: Int,ppconf_Inh_Args :: PrettyPrintConfig}+data Syn_Args = Syn_Args {comments_Syn_Args :: ([MToken]),copy_Syn_Args :: Args,isMultiline_Syn_Args :: Bool,pretty_Syn_Args :: Doc}+wrap_Args :: T_Args ->+             Inh_Args ->+             Syn_Args+wrap_Args sem (Inh_Args _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_Args _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty))+sem_Args_ListArgs :: T_MExprList ->+                     T_Args+sem_Args_ListArgs args_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _argsOisHead :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: Args+              _lhsOcomments :: ([MToken])+              _argsOcomments :: ([MToken])+              _argsOindent :: Int+              _argsOppconf :: PrettyPrintConfig+              _argsIcomments :: ([MToken])+              _argsIcopy :: MExprList+              _argsIisAssociative :: Bool+              _argsIisMultiline :: Bool+              _argsIpos :: Region+              _argsIprecedence :: OperatorLevel+              _argsIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 662 "src/GLua/AG/PrettyPrint.ag" #-}+                   parens _lhsIppconf _emptyParams     _argsIpretty+                   {-# LINE 612 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _emptyParams =+                  ({-# LINE 663 "src/GLua/AG/PrettyPrint.ag" #-}+                   toEmpty $ null _argsIcopy+                   {-# LINE 617 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOisHead =+                  ({-# LINE 664 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 622 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argsIisMultiline+                   {-# LINE 627 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ListArgs _argsIcopy+                   {-# LINE 632 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 637 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argsIcomments+                   {-# LINE 642 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 647 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 652 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 657 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _argsIcomments,_argsIcopy,_argsIisAssociative,_argsIisMultiline,_argsIpos,_argsIprecedence,_argsIpretty) =+                  args_ _argsOcomments _argsOindent _argsOisHead _argsOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+sem_Args_TableArg :: T_FieldList ->+                     T_Args+sem_Args_TableArg arg_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _argOindent :: Int+              _lhsOisMultiline :: Bool+              _lhsOcopy :: Args+              _lhsOcomments :: ([MToken])+              _argOcomments :: ([MToken])+              _argOppconf :: PrettyPrintConfig+              _argIcanFitOnSameLine :: Bool+              _argIcomments :: ([MToken])+              _argIcopy :: FieldList+              _argIisMultiline :: Bool+              _argIisNil :: Bool+              _argIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 665 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _argIisMultiline then _prettyMulti     else _prettySingle+                   {-# LINE 684 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyMulti =+                  ({-# LINE 666 "src/GLua/AG/PrettyPrint.ag" #-}+                   zchr '{' $+$ indent _lhsIppconf (_lhsIindent + 1) _argIpretty $+$ indent _lhsIppconf _lhsIindent (zchr '}')+                   {-# LINE 689 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettySingle =+                  ({-# LINE 667 "src/GLua/AG/PrettyPrint.ag" #-}+                   braces _lhsIppconf _emptyContents     _argIpretty+                   {-# LINE 694 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _emptyContents =+                  ({-# LINE 668 "src/GLua/AG/PrettyPrint.ag" #-}+                   toEmpty $ null _argIcopy+                   {-# LINE 699 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argOindent =+                  ({-# LINE 669 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + (if _argIisMultiline then 1 else 0)+                   {-# LINE 704 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argIisMultiline+                   {-# LINE 709 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   TableArg _argIcopy+                   {-# LINE 714 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 719 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argIcomments+                   {-# LINE 724 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 729 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 734 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _argIcanFitOnSameLine,_argIcomments,_argIcopy,_argIisMultiline,_argIisNil,_argIpretty) =+                  arg_ _argOcomments _argOindent _argOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+sem_Args_StringArg :: MToken ->+                      T_Args+sem_Args_StringArg arg_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisMultiline :: Bool+              _lhsOcopy :: Args+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 670 "src/GLua/AG/PrettyPrint.ag" #-}+                   tok arg_+                   {-# LINE 752 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 757 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   StringArg arg_+                   {-# LINE 762 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 767 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 772 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+-- BinOp -------------------------------------------------------+-- cata+sem_BinOp :: BinOp ->+             T_BinOp+sem_BinOp (AOr) =+    (sem_BinOp_AOr)+sem_BinOp (AAnd) =+    (sem_BinOp_AAnd)+sem_BinOp (ALT) =+    (sem_BinOp_ALT)+sem_BinOp (AGT) =+    (sem_BinOp_AGT)+sem_BinOp (ALEQ) =+    (sem_BinOp_ALEQ)+sem_BinOp (AGEQ) =+    (sem_BinOp_AGEQ)+sem_BinOp (ANEq) =+    (sem_BinOp_ANEq)+sem_BinOp (AEq) =+    (sem_BinOp_AEq)+sem_BinOp (AConcatenate) =+    (sem_BinOp_AConcatenate)+sem_BinOp (APlus) =+    (sem_BinOp_APlus)+sem_BinOp (BinMinus) =+    (sem_BinOp_BinMinus)+sem_BinOp (AMultiply) =+    (sem_BinOp_AMultiply)+sem_BinOp (ADivide) =+    (sem_BinOp_ADivide)+sem_BinOp (AModulus) =+    (sem_BinOp_AModulus)+sem_BinOp (APower) =+    (sem_BinOp_APower)+-- semantic domain+type T_BinOp = ([MToken]) ->+               Int ->+               PrettyPrintConfig ->+               ( ([MToken]),BinOp,Bool,Bool,OperatorLevel,Doc)+data Inh_BinOp = Inh_BinOp {comments_Inh_BinOp :: ([MToken]),indent_Inh_BinOp :: Int,ppconf_Inh_BinOp :: PrettyPrintConfig}+data Syn_BinOp = Syn_BinOp {comments_Syn_BinOp :: ([MToken]),copy_Syn_BinOp :: BinOp,isAssociative_Syn_BinOp :: Bool,isMultiline_Syn_BinOp :: Bool,precedence_Syn_BinOp :: OperatorLevel,pretty_Syn_BinOp :: Doc}+wrap_BinOp :: T_BinOp ->+              Inh_BinOp ->+              Syn_BinOp+wrap_BinOp sem (Inh_BinOp _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_BinOp _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty))+sem_BinOp_AOr :: T_BinOp+sem_BinOp_AOr =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 745 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText (if cStyle _lhsIppconf then "||" else "or")+                   {-# LINE 836 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 746 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel1+                   {-# LINE 841 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 747 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 846 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 851 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AOr+                   {-# LINE 856 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 861 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 866 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_AAnd :: T_BinOp+sem_BinOp_AAnd =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 742 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText (if cStyle _lhsIppconf then "&&" else "and")+                   {-# LINE 883 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 743 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel2+                   {-# LINE 888 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 744 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 893 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 898 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AAnd+                   {-# LINE 903 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 908 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 913 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_ALT :: T_BinOp+sem_BinOp_ALT =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 724 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "<"+                   {-# LINE 930 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 725 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel3+                   {-# LINE 935 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 726 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 940 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 945 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ALT+                   {-# LINE 950 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 955 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 960 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_AGT :: T_BinOp+sem_BinOp_AGT =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 730 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText ">"+                   {-# LINE 977 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 731 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel3+                   {-# LINE 982 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 732 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 987 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 992 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AGT+                   {-# LINE 997 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1002 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1007 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_ALEQ :: T_BinOp+sem_BinOp_ALEQ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 727 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "<="+                   {-# LINE 1024 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 728 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel3+                   {-# LINE 1029 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 729 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1034 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1039 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ALEQ+                   {-# LINE 1044 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1049 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1054 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_AGEQ :: T_BinOp+sem_BinOp_AGEQ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 733 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText ">="+                   {-# LINE 1071 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 734 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel3+                   {-# LINE 1076 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 735 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1081 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1086 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AGEQ+                   {-# LINE 1091 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1096 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1101 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_ANEq :: T_BinOp+sem_BinOp_ANEq =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 739 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText (if cStyle _lhsIppconf then "!=" else "~=")+                   {-# LINE 1118 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 740 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel3+                   {-# LINE 1123 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 741 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1128 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1133 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ANEq+                   {-# LINE 1138 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1143 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1148 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_AEq :: T_BinOp+sem_BinOp_AEq =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 736 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "=="+                   {-# LINE 1165 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 737 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel3+                   {-# LINE 1170 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 738 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1175 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1180 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AEq+                   {-# LINE 1185 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1190 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1195 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_AConcatenate :: T_BinOp+sem_BinOp_AConcatenate =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 721 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText ".."+                   {-# LINE 1212 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 722 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel4+                   {-# LINE 1217 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 723 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1222 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1227 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AConcatenate+                   {-# LINE 1232 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1237 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1242 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_APlus :: T_BinOp+sem_BinOp_APlus =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 703 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "+"+                   {-# LINE 1259 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 704 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel5+                   {-# LINE 1264 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 705 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1269 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1274 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   APlus+                   {-# LINE 1279 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1284 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1289 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_BinMinus :: T_BinOp+sem_BinOp_BinMinus =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 706 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "-"+                   {-# LINE 1306 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 707 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel5+                   {-# LINE 1311 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 708 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1316 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1321 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   BinMinus+                   {-# LINE 1326 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1331 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1336 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_AMultiply :: T_BinOp+sem_BinOp_AMultiply =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 709 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "*"+                   {-# LINE 1353 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 710 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel6+                   {-# LINE 1358 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 711 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1363 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1368 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AMultiply+                   {-# LINE 1373 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1378 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1383 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_ADivide :: T_BinOp+sem_BinOp_ADivide =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 712 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "/"+                   {-# LINE 1400 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 713 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel6+                   {-# LINE 1405 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 714 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1410 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1415 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ADivide+                   {-# LINE 1420 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1425 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1430 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_AModulus :: T_BinOp+sem_BinOp_AModulus =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 715 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "%"+                   {-# LINE 1447 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 716 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel6+                   {-# LINE 1452 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 717 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1457 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1462 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AModulus+                   {-# LINE 1467 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1472 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1477 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_BinOp_APower :: T_BinOp+sem_BinOp_APower =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: BinOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 718 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "^"+                   {-# LINE 1494 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 719 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 1499 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 720 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1504 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1509 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   APower+                   {-# LINE 1514 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1519 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1524 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+-- Block -------------------------------------------------------+-- cata+sem_Block :: Block ->+             T_Block+sem_Block (Block _stats _ret) =+    (sem_Block_Block (sem_MStatList _stats) (sem_AReturn _ret))+-- semantic domain+type T_Block = ([MToken]) ->+               Int ->+               PrettyPrintConfig ->+               Region ->+               ( ([MToken]),Block,Bool,Bool,Doc,Int)+data Inh_Block = Inh_Block {comments_Inh_Block :: ([MToken]),indent_Inh_Block :: Int,ppconf_Inh_Block :: PrettyPrintConfig,statRegion_Inh_Block :: Region}+data Syn_Block = Syn_Block {comments_Syn_Block :: ([MToken]),copy_Syn_Block :: Block,hasBreaking_Syn_Block :: Bool,isMultiline_Syn_Block :: Bool,pretty_Syn_Block :: Doc,statementCount_Syn_Block :: Int}+wrap_Block :: T_Block ->+              Inh_Block ->+              Syn_Block+wrap_Block sem (Inh_Block _lhsIcomments _lhsIindent _lhsIppconf _lhsIstatRegion) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpretty,_lhsOstatementCount) = sem _lhsIcomments _lhsIindent _lhsIppconf _lhsIstatRegion+     in  (Syn_Block _lhsOcomments _lhsOcopy _lhsOhasBreaking _lhsOisMultiline _lhsOpretty _lhsOstatementCount))+sem_Block_Block :: T_MStatList ->+                   T_AReturn ->+                   T_Block+sem_Block_Block stats_ ret_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _statsOisHead :: Bool+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOstatementCount :: Int+              _lhsOcopy :: Block+              _lhsOcomments :: ([MToken])+              _statsOcomments :: ([MToken])+              _statsOindent :: Int+              _statsOppconf :: PrettyPrintConfig+              _statsOstatRegion :: Region+              _retOcomments :: ([MToken])+              _retOindent :: Int+              _retOppconf :: PrettyPrintConfig+              _statsIcomments :: ([MToken])+              _statsIcopy :: MStatList+              _statsIhasBreaking :: Bool+              _statsIisLast :: Bool+              _statsIisMultiline :: Bool+              _statsIpotentiallyAmbiguousAsStatement :: Bool+              _statsIpretty :: Doc+              _statsIstatementCount :: Int+              _retIcomments :: ([MToken])+              _retIcopy :: AReturn+              _retIhasBreaking :: Bool+              _retIisMultiline :: Bool+              _retIpretty :: Doc+              _retIstatementCount :: Int+              _newl =+                  ({-# LINE 466 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _statsIstatementCount > 0 && _retIhasBreaking then zchr '\n' else empty+                   {-# LINE 1586 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 467 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statsIpretty <> _newl     $+$ _retIpretty+                   {-# LINE 1591 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statsOisHead =+                  ({-# LINE 468 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1596 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statsIhasBreaking || _retIhasBreaking+                   {-# LINE 1601 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statsIisMultiline || _retIisMultiline+                   {-# LINE 1606 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOstatementCount =+                  ({-# LINE 287 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statsIstatementCount + _retIstatementCount+                   {-# LINE 1611 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   Block _statsIcopy _retIcopy+                   {-# LINE 1616 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1621 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _retIcomments+                   {-# LINE 1626 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1631 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 1636 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 1641 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statsOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 1646 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _retOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statsIcomments+                   {-# LINE 1651 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _retOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 1656 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _retOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 1661 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _statsIcomments,_statsIcopy,_statsIhasBreaking,_statsIisLast,_statsIisMultiline,_statsIpotentiallyAmbiguousAsStatement,_statsIpretty,_statsIstatementCount) =+                  stats_ _statsOcomments _statsOindent _statsOisHead _statsOppconf _statsOstatRegion+              ( _retIcomments,_retIcopy,_retIhasBreaking,_retIisMultiline,_retIpretty,_retIstatementCount) =+                  ret_ _retOcomments _retOindent _retOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpretty,_lhsOstatementCount)))+-- Declaration -------------------------------------------------+-- cata+sem_Declaration :: Declaration ->+                   T_Declaration+sem_Declaration ( x1,x2) =+    (sem_Declaration_Tuple (sem_PrefixExp x1) (sem_MaybeMExpr x2))+-- semantic domain+type T_Declaration = ([MToken]) ->+                     Int ->+                     PrettyPrintConfig ->+                     ( ([MToken]),Declaration,Doc,Bool,Bool,Doc,Doc,Bool)+data Inh_Declaration = Inh_Declaration {comments_Inh_Declaration :: ([MToken]),indent_Inh_Declaration :: Int,ppconf_Inh_Declaration :: PrettyPrintConfig}+data Syn_Declaration = Syn_Declaration {comments_Syn_Declaration :: ([MToken]),copy_Syn_Declaration :: Declaration,exprPretty_Syn_Declaration :: Doc,isDefined_Syn_Declaration :: Bool,isMultiline_Syn_Declaration :: Bool,pretty_Syn_Declaration :: Doc,varPretty_Syn_Declaration :: Doc,wouldBeAmbiguousIfNextStatementIsExprVar_Syn_Declaration :: Bool}+wrap_Declaration :: T_Declaration ->+                    Inh_Declaration ->+                    Syn_Declaration+wrap_Declaration sem (Inh_Declaration _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOexprPretty,_lhsOisDefined,_lhsOisMultiline,_lhsOpretty,_lhsOvarPretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_Declaration _lhsOcomments _lhsOcopy _lhsOexprPretty _lhsOisDefined _lhsOisMultiline _lhsOpretty _lhsOvarPretty _lhsOwouldBeAmbiguousIfNextStatementIsExprVar))+sem_Declaration_Tuple :: T_PrefixExp ->+                         T_MaybeMExpr ->+                         T_Declaration+sem_Declaration_Tuple x1_ x2_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOvarPretty :: Doc+              _lhsOexprPretty :: Doc+              _x1OparentOperatorPrecedence :: OperatorLevel+              _x1OparentOperatorAssociative :: Bool+              _lhsOisDefined :: Bool+              _lhsOisMultiline :: Bool+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Declaration+              _lhsOcomments :: ([MToken])+              _lhsOpretty :: Doc+              _x1Ocomments :: ([MToken])+              _x1Oindent :: Int+              _x1Oppconf :: PrettyPrintConfig+              _x2Ocomments :: ([MToken])+              _x2Oindent :: Int+              _x2Oppconf :: PrettyPrintConfig+              _x1Icomments :: ([MToken])+              _x1Icopy :: PrefixExp+              _x1IisAssociative :: Bool+              _x1IisLiteral :: Bool+              _x1IisMultiline :: Bool+              _x1IpotentiallyAmbiguousAsStatement :: Bool+              _x1Iprecedence :: OperatorLevel+              _x1Ipretty :: Doc+              _x2Icomments :: ([MToken])+              _x2Icopy :: MaybeMExpr+              _x2IisAssociative :: Bool+              _x2IisDefined :: Bool+              _x2IisMultiline :: Bool+              _x2Iprecedence :: OperatorLevel+              _x2Ipretty :: Doc+              _x2IwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOvarPretty =+                  ({-# LINE 406 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x1Ipretty+                   {-# LINE 1729 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOexprPretty =+                  ({-# LINE 407 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x2Ipretty+                   {-# LINE 1734 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1OparentOperatorPrecedence =+                  ({-# LINE 408 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 1739 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1OparentOperatorAssociative =+                  ({-# LINE 409 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1744 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisDefined =+                  ({-# LINE 259 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x2IisDefined+                   {-# LINE 1749 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x1IisMultiline || _x2IisMultiline+                   {-# LINE 1754 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x2IwouldBeAmbiguousIfNextStatementIsExprVar+                   {-# LINE 1759 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   (_x1Icopy,_x2Icopy)+                   {-# LINE 1764 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1769 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x2Icomments+                   {-# LINE 1774 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 232 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x2Ipretty+                   {-# LINE 1779 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1Ocomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1784 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1Oindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 1789 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1Oppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 1794 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x2Ocomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x1Icomments+                   {-# LINE 1799 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x2Oindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 1804 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x2Oppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 1809 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _x1Icomments,_x1Icopy,_x1IisAssociative,_x1IisLiteral,_x1IisMultiline,_x1IpotentiallyAmbiguousAsStatement,_x1Iprecedence,_x1Ipretty) =+                  x1_ _x1Ocomments _x1Oindent _x1OparentOperatorAssociative _x1OparentOperatorPrecedence _x1Oppconf+              ( _x2Icomments,_x2Icopy,_x2IisAssociative,_x2IisDefined,_x2IisMultiline,_x2Iprecedence,_x2Ipretty,_x2IwouldBeAmbiguousIfNextStatementIsExprVar) =+                  x2_ _x2Ocomments _x2Oindent _x2Oppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOexprPretty,_lhsOisDefined,_lhsOisMultiline,_lhsOpretty,_lhsOvarPretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+-- Else --------------------------------------------------------+-- cata+sem_Else :: Else ->+            T_Else+sem_Else (Prelude.Just x) =+    (sem_Else_Just (sem_MElse x))+sem_Else Prelude.Nothing =+    sem_Else_Nothing+-- semantic domain+type T_Else = ([MToken]) ->+              Int ->+              PrettyPrintConfig ->+              Region ->+              ( ([MToken]),Else,Bool,Bool,Region,Doc)+data Inh_Else = Inh_Else {comments_Inh_Else :: ([MToken]),indent_Inh_Else :: Int,ppconf_Inh_Else :: PrettyPrintConfig,statRegion_Inh_Else :: Region}+data Syn_Else = Syn_Else {comments_Syn_Else :: ([MToken]),copy_Syn_Else :: Else,elsesExist_Syn_Else :: Bool,isMultiline_Syn_Else :: Bool,pos_Syn_Else :: Region,pretty_Syn_Else :: Doc}+wrap_Else :: T_Else ->+             Inh_Else ->+             Syn_Else+wrap_Else sem (Inh_Else _lhsIcomments _lhsIindent _lhsIppconf _lhsIstatRegion) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOelsesExist,_lhsOisMultiline,_lhsOpos,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf _lhsIstatRegion+     in  (Syn_Else _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty))+sem_Else_Just :: T_MElse ->+                 T_Else+sem_Else_Just just_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOelsesExist :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: Else+              _lhsOcomments :: ([MToken])+              _lhsOpos :: Region+              _lhsOpretty :: Doc+              _justOcomments :: ([MToken])+              _justOindent :: Int+              _justOppconf :: PrettyPrintConfig+              _justOstatRegion :: Region+              _justIcomments :: ([MToken])+              _justIcopy :: MElse+              _justIelsesExist :: Bool+              _justIisMultiline :: Bool+              _justIpos :: Region+              _justIpretty :: Doc+              _lhsOelsesExist =+                  ({-# LINE 443 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 1864 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIisMultiline+                   {-# LINE 1869 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   Just _justIcopy+                   {-# LINE 1874 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1879 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIcomments+                   {-# LINE 1884 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 271 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIpos+                   {-# LINE 1889 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 232 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIpretty+                   {-# LINE 1894 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1899 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 1904 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 1909 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 1914 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _justIcomments,_justIcopy,_justIelsesExist,_justIisMultiline,_justIpos,_justIpretty) =+                  just_ _justOcomments _justOindent _justOppconf _justOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOelsesExist,_lhsOisMultiline,_lhsOpos,_lhsOpretty)))+sem_Else_Nothing :: T_Else+sem_Else_Nothing =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOpos :: Region+              _lhsOelsesExist :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: Else+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 444 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 1934 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 445 "src/GLua/AG/PrettyPrint.ag" #-}+                   emptyRg+                   {-# LINE 1939 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOelsesExist =+                  ({-# LINE 293 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1944 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 1949 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   Nothing+                   {-# LINE 1954 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 1959 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 1964 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOelsesExist,_lhsOisMultiline,_lhsOpos,_lhsOpretty)))+-- ElseIf ------------------------------------------------------+-- cata+sem_ElseIf :: ElseIf ->+              T_ElseIf+sem_ElseIf ( x1,x2) =+    (sem_ElseIf_Tuple (sem_MExpr x1) (sem_Block x2))+-- semantic domain+type T_ElseIf = ([MToken]) ->+                Int ->+                PrettyPrintConfig ->+                ( ([MToken]),ElseIf,Bool,Doc)+data Inh_ElseIf = Inh_ElseIf {comments_Inh_ElseIf :: ([MToken]),indent_Inh_ElseIf :: Int,ppconf_Inh_ElseIf :: PrettyPrintConfig}+data Syn_ElseIf = Syn_ElseIf {comments_Syn_ElseIf :: ([MToken]),copy_Syn_ElseIf :: ElseIf,isMultiline_Syn_ElseIf :: Bool,pretty_Syn_ElseIf :: Doc}+wrap_ElseIf :: T_ElseIf ->+               Inh_ElseIf ->+               Syn_ElseIf+wrap_ElseIf sem (Inh_ElseIf _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_ElseIf _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty))+sem_ElseIf_Tuple :: T_MExpr ->+                    T_Block ->+                    T_ElseIf+sem_ElseIf_Tuple x1_ x2_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _x2Oindent :: Int+              _x2OstatRegion :: Region+              _x1OparentOperatorPrecedence :: OperatorLevel+              _x1OparentOperatorAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: ElseIf+              _lhsOcomments :: ([MToken])+              _x1Ocomments :: ([MToken])+              _x1Oindent :: Int+              _x1Oppconf :: PrettyPrintConfig+              _x2Ocomments :: ([MToken])+              _x2Oppconf :: PrettyPrintConfig+              _x1Icomments :: ([MToken])+              _x1Icopy :: MExpr+              _x1IisAssociative :: Bool+              _x1IisLiteral :: Bool+              _x1IisMultiline :: Bool+              _x1Ipos :: Region+              _x1Iprecedence :: OperatorLevel+              _x1Ipretty :: Doc+              _x1IwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _x2Icomments :: ([MToken])+              _x2Icopy :: Block+              _x2IhasBreaking :: Bool+              _x2IisMultiline :: Bool+              _x2Ipretty :: Doc+              _x2IstatementCount :: Int+              _lhsOpretty =+                  ({-# LINE 426 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "elseif" <-> _x1Ipretty <-> zeroWidthText "then" $+$ _x2Ipretty+                   {-# LINE 2024 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x2Oindent =+                  ({-# LINE 427 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 2029 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x2OstatRegion =+                  ({-# LINE 428 "src/GLua/AG/PrettyPrint.ag" #-}+                   emptyRg+                   {-# LINE 2034 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1OparentOperatorPrecedence =+                  ({-# LINE 429 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 2039 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1OparentOperatorAssociative =+                  ({-# LINE 430 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2044 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x1IisMultiline || _x2IisMultiline+                   {-# LINE 2049 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   (_x1Icopy,_x2Icopy)+                   {-# LINE 2054 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2059 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x2Icomments+                   {-# LINE 2064 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1Ocomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2069 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1Oindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 2074 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x1Oppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 2079 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x2Ocomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _x1Icomments+                   {-# LINE 2084 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _x2Oppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 2089 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _x1Icomments,_x1Icopy,_x1IisAssociative,_x1IisLiteral,_x1IisMultiline,_x1Ipos,_x1Iprecedence,_x1Ipretty,_x1IwouldBeAmbiguousIfNextStatementIsExprVar) =+                  x1_ _x1Ocomments _x1Oindent _x1OparentOperatorAssociative _x1OparentOperatorPrecedence _x1Oppconf+              ( _x2Icomments,_x2Icopy,_x2IhasBreaking,_x2IisMultiline,_x2Ipretty,_x2IstatementCount) =+                  x2_ _x2Ocomments _x2Oindent _x2Oppconf _x2OstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+-- ElseIfList --------------------------------------------------+-- cata+sem_ElseIfList :: ElseIfList ->+                  T_ElseIfList+sem_ElseIfList list =+    (Prelude.foldr sem_ElseIfList_Cons sem_ElseIfList_Nil (Prelude.map sem_MElseIf list))+-- semantic domain+type T_ElseIfList = ([MToken]) ->+                    Int ->+                    PrettyPrintConfig ->+                    ( ([MToken]),ElseIfList,Bool,Bool,Region,Doc)+data Inh_ElseIfList = Inh_ElseIfList {comments_Inh_ElseIfList :: ([MToken]),indent_Inh_ElseIfList :: Int,ppconf_Inh_ElseIfList :: PrettyPrintConfig}+data Syn_ElseIfList = Syn_ElseIfList {comments_Syn_ElseIfList :: ([MToken]),copy_Syn_ElseIfList :: ElseIfList,elsesExist_Syn_ElseIfList :: Bool,isMultiline_Syn_ElseIfList :: Bool,pos_Syn_ElseIfList :: Region,pretty_Syn_ElseIfList :: Doc}+wrap_ElseIfList :: T_ElseIfList ->+                   Inh_ElseIfList ->+                   Syn_ElseIfList+wrap_ElseIfList sem (Inh_ElseIfList _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOelsesExist,_lhsOisMultiline,_lhsOpos,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_ElseIfList _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty))+sem_ElseIfList_Cons :: T_MElseIf ->+                       T_ElseIfList ->+                       T_ElseIfList+sem_ElseIfList_Cons hd_ tl_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOelsesExist :: Bool+              _lhsOpos :: Region+              _lhsOisMultiline :: Bool+              _lhsOcopy :: ElseIfList+              _lhsOcomments :: ([MToken])+              _hdOcomments :: ([MToken])+              _hdOindent :: Int+              _hdOppconf :: PrettyPrintConfig+              _tlOcomments :: ([MToken])+              _tlOindent :: Int+              _tlOppconf :: PrettyPrintConfig+              _hdIcomments :: ([MToken])+              _hdIcopy :: MElseIf+              _hdIisMultiline :: Bool+              _hdIpos :: Region+              _hdIpretty :: Doc+              _tlIcomments :: ([MToken])+              _tlIcopy :: ElseIfList+              _tlIelsesExist :: Bool+              _tlIisMultiline :: Bool+              _tlIpos :: Region+              _tlIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 436 "src/GLua/AG/PrettyPrint.ag" #-}+                   indent _lhsIppconf _lhsIindent _hdIpretty $+$ _tlIpretty+                   {-# LINE 2148 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOelsesExist =+                  ({-# LINE 437 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2153 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 438 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIpos+                   {-# LINE 2158 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisMultiline || _tlIisMultiline+                   {-# LINE 2163 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   (:) _hdIcopy _tlIcopy+                   {-# LINE 2168 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2173 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIcomments+                   {-# LINE 2178 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2183 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 2188 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 2193 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIcomments+                   {-# LINE 2198 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 2203 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 2208 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _hdIcomments,_hdIcopy,_hdIisMultiline,_hdIpos,_hdIpretty) =+                  hd_ _hdOcomments _hdOindent _hdOppconf+              ( _tlIcomments,_tlIcopy,_tlIelsesExist,_tlIisMultiline,_tlIpos,_tlIpretty) =+                  tl_ _tlOcomments _tlOindent _tlOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOelsesExist,_lhsOisMultiline,_lhsOpos,_lhsOpretty)))+sem_ElseIfList_Nil :: T_ElseIfList+sem_ElseIfList_Nil =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOpos :: Region+              _lhsOelsesExist :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: ElseIfList+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 439 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 2229 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 440 "src/GLua/AG/PrettyPrint.ag" #-}+                   emptyRg+                   {-# LINE 2234 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOelsesExist =+                  ({-# LINE 293 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2239 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2244 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   []+                   {-# LINE 2249 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2254 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2259 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOelsesExist,_lhsOisMultiline,_lhsOpos,_lhsOpretty)))+-- Expr --------------------------------------------------------+-- cata+sem_Expr :: Expr ->+            T_Expr+sem_Expr (ANil) =+    (sem_Expr_ANil)+sem_Expr (AFalse) =+    (sem_Expr_AFalse)+sem_Expr (ATrue) =+    (sem_Expr_ATrue)+sem_Expr (ANumber _num) =+    (sem_Expr_ANumber _num)+sem_Expr (AString _str) =+    (sem_Expr_AString _str)+sem_Expr (AVarArg) =+    (sem_Expr_AVarArg)+sem_Expr (AnonymousFunc _pars _body) =+    (sem_Expr_AnonymousFunc _pars (sem_Block _body))+sem_Expr (APrefixExpr _pexpr) =+    (sem_Expr_APrefixExpr (sem_PrefixExp _pexpr))+sem_Expr (ATableConstructor _fields) =+    (sem_Expr_ATableConstructor (sem_FieldList _fields))+sem_Expr (BinOpExpr _op _left _right) =+    (sem_Expr_BinOpExpr (sem_BinOp _op) (sem_MExpr _left) (sem_MExpr _right))+sem_Expr (UnOpExpr _op _right) =+    (sem_Expr_UnOpExpr (sem_UnOp _op) (sem_MExpr _right))+-- semantic domain+type T_Expr = ([MToken]) ->+              Int ->+              Bool ->+              OperatorLevel ->+              PrettyPrintConfig ->+              Region ->+              ( ([MToken]),Expr,Bool,Bool,Bool,OperatorLevel,Doc,Bool)+data Inh_Expr = Inh_Expr {comments_Inh_Expr :: ([MToken]),indent_Inh_Expr :: Int,parentOperatorAssociative_Inh_Expr :: Bool,parentOperatorPrecedence_Inh_Expr :: OperatorLevel,ppconf_Inh_Expr :: PrettyPrintConfig,statRegion_Inh_Expr :: Region}+data Syn_Expr = Syn_Expr {comments_Syn_Expr :: ([MToken]),copy_Syn_Expr :: Expr,isAssociative_Syn_Expr :: Bool,isLiteral_Syn_Expr :: Bool,isMultiline_Syn_Expr :: Bool,precedence_Syn_Expr :: OperatorLevel,pretty_Syn_Expr :: Doc,wouldBeAmbiguousIfNextStatementIsExprVar_Syn_Expr :: Bool}+wrap_Expr :: T_Expr ->+             Inh_Expr ->+             Syn_Expr+wrap_Expr sem (Inh_Expr _lhsIcomments _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf _lhsIstatRegion) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar) = sem _lhsIcomments _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf _lhsIstatRegion+     in  (Syn_Expr _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOprecedence _lhsOpretty _lhsOwouldBeAmbiguousIfNextStatementIsExprVar))+sem_Expr_ANil :: T_Expr+sem_Expr_ANil =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOisLiteral :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 620 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "nil"+                   {-# LINE 2323 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 621 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2328 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2333 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2338 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 2343 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2348 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ANil+                   {-# LINE 2353 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2358 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2363 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_AFalse :: T_Expr+sem_Expr_AFalse =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOisLiteral :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 622 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "false"+                   {-# LINE 2385 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 623 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2390 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2395 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2400 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 2405 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2410 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AFalse+                   {-# LINE 2415 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2420 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2425 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_ATrue :: T_Expr+sem_Expr_ATrue =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOisLiteral :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 624 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "true"+                   {-# LINE 2447 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 625 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2452 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2457 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2462 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 2467 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2472 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ATrue+                   {-# LINE 2477 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2482 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2487 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_ANumber :: String ->+                    T_Expr+sem_Expr_ANumber num_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOisLiteral :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 626 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText num_+                   {-# LINE 2510 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 627 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2515 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2520 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2525 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 2530 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2535 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ANumber num_+                   {-# LINE 2540 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2545 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2550 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_AString :: MToken ->+                    T_Expr+sem_Expr_AString str_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOisLiteral :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 628 "src/GLua/AG/PrettyPrint.ag" #-}+                   tok str_+                   {-# LINE 2573 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 629 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2578 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2583 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2588 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 2593 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2598 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AString str_+                   {-# LINE 2603 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2608 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2613 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_AVarArg :: T_Expr+sem_Expr_AVarArg =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOisLiteral :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 630 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "..."+                   {-# LINE 2635 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 631 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2640 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2645 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2650 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 2655 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2660 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AVarArg+                   {-# LINE 2665 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2670 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2675 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_AnonymousFunc :: ([MToken]) ->+                          T_Block ->+                          T_Expr+sem_Expr_AnonymousFunc pars_ body_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _bodyOindent :: Int+              _lhsOpretty :: Doc+              _lhsOisAssociative :: Bool+              _lhsOisLiteral :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _isMultiline =+                  ({-# LINE 632 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIisMultiline || _bodyIstatementCount > 1 || (_bodyIstatementCount == 1 && not _bodyIhasBreaking)+                   {-# LINE 2709 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _singleLinePretty =+                  ({-# LINE 633 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "function" <> parens _lhsIppconf _emptyParams     (printList tok (render _comma    ) pars_) <-> _bodyIpretty <-> zeroWidthText "end"+                   {-# LINE 2714 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _multilinePretty =+                  ({-# LINE 634 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "function" <> parens _lhsIppconf _emptyParams     (printList tok (render _comma    ) pars_) $+$ _bodyIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")+                   {-# LINE 2719 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _comma =+                  ({-# LINE 635 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ',' <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)+                   {-# LINE 2724 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _emptyParams =+                  ({-# LINE 636 "src/GLua/AG/PrettyPrint.ag" #-}+                   toEmpty $ null pars_+                   {-# LINE 2729 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 637 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _isMultiline     then _lhsIindent + 1 else 0+                   {-# LINE 2734 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 638 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _isMultiline     then _multilinePretty     else _singleLinePretty+                   {-# LINE 2739 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2744 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 246 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2749 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _isMultiline+                   {-# LINE 2754 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 2759 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2764 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AnonymousFunc pars_ _bodyIcopy+                   {-# LINE 2769 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2774 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 2779 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2784 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 2789 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 2794 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_APrefixExpr :: T_PrefixExp ->+                        T_Expr+sem_Expr_APrefixExpr pexpr_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisLiteral :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _pexprOcomments :: ([MToken])+              _pexprOindent :: Int+              _pexprOparentOperatorAssociative :: Bool+              _pexprOparentOperatorPrecedence :: OperatorLevel+              _pexprOppconf :: PrettyPrintConfig+              _pexprIcomments :: ([MToken])+              _pexprIcopy :: PrefixExp+              _pexprIisAssociative :: Bool+              _pexprIisLiteral :: Bool+              _pexprIisMultiline :: Bool+              _pexprIpotentiallyAmbiguousAsStatement :: Bool+              _pexprIprecedence :: OperatorLevel+              _pexprIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 639 "src/GLua/AG/PrettyPrint.ag" #-}+                   _pexprIpretty+                   {-# LINE 2832 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 640 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2837 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _pexprIisAssociative+                   {-# LINE 2842 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 246 "src/GLua/AG/PrettyPrint.ag" #-}+                   _pexprIisLiteral+                   {-# LINE 2847 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _pexprIisMultiline+                   {-# LINE 2852 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   _pexprIprecedence+                   {-# LINE 2857 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   APrefixExpr _pexprIcopy+                   {-# LINE 2862 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2867 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _pexprIcomments+                   {-# LINE 2872 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _pexprOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2877 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _pexprOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 2882 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _pexprOparentOperatorAssociative =+                  ({-# LINE 243 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIparentOperatorAssociative+                   {-# LINE 2887 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _pexprOparentOperatorPrecedence =+                  ({-# LINE 242 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIparentOperatorPrecedence+                   {-# LINE 2892 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _pexprOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 2897 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _pexprIcomments,_pexprIcopy,_pexprIisAssociative,_pexprIisLiteral,_pexprIisMultiline,_pexprIpotentiallyAmbiguousAsStatement,_pexprIprecedence,_pexprIpretty) =+                  pexpr_ _pexprOcomments _pexprOindent _pexprOparentOperatorAssociative _pexprOparentOperatorPrecedence _pexprOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_ATableConstructor :: T_FieldList ->+                              T_Expr+sem_Expr_ATableConstructor fields_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOisMultiline :: Bool+              _lhsOisLiteral :: Bool+              _fieldsOindent :: Int+              _lhsOisAssociative :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _fieldsOcomments :: ([MToken])+              _fieldsOppconf :: PrettyPrintConfig+              _fieldsIcanFitOnSameLine :: Bool+              _fieldsIcomments :: ([MToken])+              _fieldsIcopy :: FieldList+              _fieldsIisMultiline :: Bool+              _fieldsIisNil :: Bool+              _fieldsIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 642 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _fieldsIisMultiline then _prettyMulti     else _prettySingle+                   {-# LINE 2931 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 643 "src/GLua/AG/PrettyPrint.ag" #-}+                   not $ null $ _fieldsIcopy+                   {-# LINE 2936 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 644 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 2941 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyMulti =+                  ({-# LINE 645 "src/GLua/AG/PrettyPrint.ag" #-}+                   zchr '{' $+$ indent _lhsIppconf (_lhsIindent + 1) _fieldsIpretty $+$ indent _lhsIppconf _lhsIindent (zchr '}')+                   {-# LINE 2946 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettySingle =+                  ({-# LINE 646 "src/GLua/AG/PrettyPrint.ag" #-}+                   braces _lhsIppconf _emptyContents     _fieldsIpretty+                   {-# LINE 2951 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _emptyContents =+                  ({-# LINE 647 "src/GLua/AG/PrettyPrint.ag" #-}+                   toEmpty $ null _fieldsIcopy+                   {-# LINE 2956 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _fieldsOindent =+                  ({-# LINE 648 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + (if _fieldsIisMultiline then 1 else 0)+                   {-# LINE 2961 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2966 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 2971 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 2976 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ATableConstructor _fieldsIcopy+                   {-# LINE 2981 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 2986 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _fieldsIcomments+                   {-# LINE 2991 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _fieldsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 2996 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _fieldsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3001 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _fieldsIcanFitOnSameLine,_fieldsIcomments,_fieldsIcopy,_fieldsIisMultiline,_fieldsIisNil,_fieldsIpretty) =+                  fields_ _fieldsOcomments _fieldsOindent _fieldsOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_BinOpExpr :: T_BinOp ->+                      T_MExpr ->+                      T_MExpr ->+                      T_Expr+sem_Expr_BinOpExpr op_ left_ right_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _leftOparentOperatorPrecedence :: OperatorLevel+              _rightOparentOperatorPrecedence :: OperatorLevel+              _leftOparentOperatorAssociative :: Bool+              _rightOparentOperatorAssociative :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisLiteral :: Bool+              _lhsOisMultiline :: Bool+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _opOcomments :: ([MToken])+              _opOindent :: Int+              _opOppconf :: PrettyPrintConfig+              _leftOcomments :: ([MToken])+              _leftOindent :: Int+              _leftOppconf :: PrettyPrintConfig+              _rightOcomments :: ([MToken])+              _rightOindent :: Int+              _rightOppconf :: PrettyPrintConfig+              _opIcomments :: ([MToken])+              _opIcopy :: BinOp+              _opIisAssociative :: Bool+              _opIisMultiline :: Bool+              _opIprecedence :: OperatorLevel+              _opIpretty :: Doc+              _leftIcomments :: ([MToken])+              _leftIcopy :: MExpr+              _leftIisAssociative :: Bool+              _leftIisLiteral :: Bool+              _leftIisMultiline :: Bool+              _leftIpos :: Region+              _leftIprecedence :: OperatorLevel+              _leftIpretty :: Doc+              _leftIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _rightIcomments :: ([MToken])+              _rightIcopy :: MExpr+              _rightIisAssociative :: Bool+              _rightIisLiteral :: Bool+              _rightIisMultiline :: Bool+              _rightIpos :: Region+              _rightIprecedence :: OperatorLevel+              _rightIpretty :: Doc+              _rightIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpretty =+                  ({-# LINE 649 "src/GLua/AG/PrettyPrint.ag" #-}+                   _leftIpretty <-> _opIpretty <-> _rightIpretty+                   {-# LINE 3065 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 652 "src/GLua/AG/PrettyPrint.ag" #-}+                   min _opIprecedence $ min _leftIprecedence _rightIprecedence+                   {-# LINE 3070 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _leftOparentOperatorPrecedence =+                  ({-# LINE 653 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIprecedence+                   {-# LINE 3075 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOparentOperatorPrecedence =+                  ({-# LINE 654 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIprecedence+                   {-# LINE 3080 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _leftOparentOperatorAssociative =+                  ({-# LINE 655 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIisAssociative+                   {-# LINE 3085 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOparentOperatorAssociative =+                  ({-# LINE 656 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIisAssociative+                   {-# LINE 3090 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIisAssociative && _leftIisAssociative && _rightIisAssociative+                   {-# LINE 3095 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 246 "src/GLua/AG/PrettyPrint.ag" #-}+                   ((\_ _ -> False) _leftIisLiteral _rightIisLiteral)+                   {-# LINE 3100 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIisMultiline || _leftIisMultiline || _rightIisMultiline+                   {-# LINE 3105 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   _leftIwouldBeAmbiguousIfNextStatementIsExprVar || _rightIwouldBeAmbiguousIfNextStatementIsExprVar+                   {-# LINE 3110 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   BinOpExpr _opIcopy _leftIcopy _rightIcopy+                   {-# LINE 3115 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 3120 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _rightIcomments+                   {-# LINE 3125 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _opOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 3130 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _opOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3135 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _opOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3140 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _leftOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIcomments+                   {-# LINE 3145 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _leftOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3150 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _leftOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3155 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _leftIcomments+                   {-# LINE 3160 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3165 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3170 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _opIcomments,_opIcopy,_opIisAssociative,_opIisMultiline,_opIprecedence,_opIpretty) =+                  op_ _opOcomments _opOindent _opOppconf+              ( _leftIcomments,_leftIcopy,_leftIisAssociative,_leftIisLiteral,_leftIisMultiline,_leftIpos,_leftIprecedence,_leftIpretty,_leftIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  left_ _leftOcomments _leftOindent _leftOparentOperatorAssociative _leftOparentOperatorPrecedence _leftOppconf+              ( _rightIcomments,_rightIcopy,_rightIisAssociative,_rightIisLiteral,_rightIisMultiline,_rightIpos,_rightIprecedence,_rightIpretty,_rightIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  right_ _rightOcomments _rightOindent _rightOparentOperatorAssociative _rightOparentOperatorPrecedence _rightOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_Expr_UnOpExpr :: T_UnOp ->+                     T_MExpr ->+                     T_Expr+sem_Expr_UnOpExpr op_ right_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _rightOparentOperatorPrecedence :: OperatorLevel+              _lhsOisAssociative :: Bool+              _lhsOisLiteral :: Bool+              _lhsOisMultiline :: Bool+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: Expr+              _lhsOcomments :: ([MToken])+              _opOcomments :: ([MToken])+              _opOindent :: Int+              _opOppconf :: PrettyPrintConfig+              _rightOcomments :: ([MToken])+              _rightOindent :: Int+              _rightOparentOperatorAssociative :: Bool+              _rightOppconf :: PrettyPrintConfig+              _opIcomments :: ([MToken])+              _opIcopy :: UnOp+              _opIisMultiline :: Bool+              _opIpretty :: Doc+              _rightIcomments :: ([MToken])+              _rightIcopy :: MExpr+              _rightIisAssociative :: Bool+              _rightIisLiteral :: Bool+              _rightIisMultiline :: Bool+              _rightIpos :: Region+              _rightIprecedence :: OperatorLevel+              _rightIpretty :: Doc+              _rightIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpretty =+                  ({-# LINE 657 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIpretty <> _rightIpretty+                   {-# LINE 3221 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 658 "src/GLua/AG/PrettyPrint.ag" #-}+                   min _rightIprecedence OperatorLevel7+                   {-# LINE 3226 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOparentOperatorPrecedence =+                  ({-# LINE 659 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel7+                   {-# LINE 3231 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _rightIisAssociative+                   {-# LINE 3236 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 246 "src/GLua/AG/PrettyPrint.ag" #-}+                   _rightIisLiteral+                   {-# LINE 3241 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIisMultiline || _rightIisMultiline+                   {-# LINE 3246 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   _rightIwouldBeAmbiguousIfNextStatementIsExprVar+                   {-# LINE 3251 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   UnOpExpr _opIcopy _rightIcopy+                   {-# LINE 3256 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 3261 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _rightIcomments+                   {-# LINE 3266 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _opOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 3271 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _opOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3276 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _opOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3281 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _opIcomments+                   {-# LINE 3286 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3291 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOparentOperatorAssociative =+                  ({-# LINE 243 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIparentOperatorAssociative+                   {-# LINE 3296 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _rightOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3301 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _opIcomments,_opIcopy,_opIisMultiline,_opIpretty) =+                  op_ _opOcomments _opOindent _opOppconf+              ( _rightIcomments,_rightIcopy,_rightIisAssociative,_rightIisLiteral,_rightIisMultiline,_rightIpos,_rightIprecedence,_rightIpretty,_rightIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  right_ _rightOcomments _rightOindent _rightOparentOperatorAssociative _rightOparentOperatorPrecedence _rightOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+-- ExprSuffixList ----------------------------------------------+-- cata+sem_ExprSuffixList :: ExprSuffixList ->+                      T_ExprSuffixList+sem_ExprSuffixList list =+    (Prelude.foldr sem_ExprSuffixList_Cons sem_ExprSuffixList_Nil (Prelude.map sem_PFExprSuffix list))+-- semantic domain+type T_ExprSuffixList = ([MToken]) ->+                        Int ->+                        PrettyPrintConfig ->+                        ( ([MToken]),ExprSuffixList,Bool,Bool,OperatorLevel,Doc)+data Inh_ExprSuffixList = Inh_ExprSuffixList {comments_Inh_ExprSuffixList :: ([MToken]),indent_Inh_ExprSuffixList :: Int,ppconf_Inh_ExprSuffixList :: PrettyPrintConfig}+data Syn_ExprSuffixList = Syn_ExprSuffixList {comments_Syn_ExprSuffixList :: ([MToken]),copy_Syn_ExprSuffixList :: ExprSuffixList,isAssociative_Syn_ExprSuffixList :: Bool,isMultiline_Syn_ExprSuffixList :: Bool,precedence_Syn_ExprSuffixList :: OperatorLevel,pretty_Syn_ExprSuffixList :: Doc}+wrap_ExprSuffixList :: T_ExprSuffixList ->+                       Inh_ExprSuffixList ->+                       Syn_ExprSuffixList+wrap_ExprSuffixList sem (Inh_ExprSuffixList _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_ExprSuffixList _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty))+sem_ExprSuffixList_Cons :: T_PFExprSuffix ->+                           T_ExprSuffixList ->+                           T_ExprSuffixList+sem_ExprSuffixList_Cons hd_ tl_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: ExprSuffixList+              _lhsOcomments :: ([MToken])+              _hdOcomments :: ([MToken])+              _hdOindent :: Int+              _hdOppconf :: PrettyPrintConfig+              _tlOcomments :: ([MToken])+              _tlOindent :: Int+              _tlOppconf :: PrettyPrintConfig+              _hdIcomments :: ([MToken])+              _hdIcopy :: PFExprSuffix+              _hdIisAssociative :: Bool+              _hdIisMultiline :: Bool+              _hdIprecedence :: OperatorLevel+              _hdIpretty :: Doc+              _tlIcomments :: ([MToken])+              _tlIcopy :: ExprSuffixList+              _tlIisAssociative :: Bool+              _tlIisMultiline :: Bool+              _tlIprecedence :: OperatorLevel+              _tlIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 456 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIpretty <> _tlIpretty+                   {-# LINE 3361 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisAssociative && _tlIisAssociative+                   {-# LINE 3366 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisMultiline || _tlIisMultiline+                   {-# LINE 3371 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   (min _hdIprecedence _tlIprecedence)+                   {-# LINE 3376 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   (:) _hdIcopy _tlIcopy+                   {-# LINE 3381 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 3386 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIcomments+                   {-# LINE 3391 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 3396 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3401 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3406 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIcomments+                   {-# LINE 3411 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3416 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3421 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _hdIcomments,_hdIcopy,_hdIisAssociative,_hdIisMultiline,_hdIprecedence,_hdIpretty) =+                  hd_ _hdOcomments _hdOindent _hdOppconf+              ( _tlIcomments,_tlIcopy,_tlIisAssociative,_tlIisMultiline,_tlIprecedence,_tlIpretty) =+                  tl_ _tlOcomments _tlOindent _tlOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_ExprSuffixList_Nil :: T_ExprSuffixList+sem_ExprSuffixList_Nil =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: ExprSuffixList+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 457 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 3442 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 3447 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 3452 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 3457 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   []+                   {-# LINE 3462 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 3467 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 3472 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+-- Field -------------------------------------------------------+-- cata+sem_Field :: Field ->+             T_Field+sem_Field (ExprField _key _value _sep) =+    (sem_Field_ExprField (sem_MExpr _key) (sem_MExpr _value) (sem_FieldSep _sep))+sem_Field (NamedField _key _value _sep) =+    (sem_Field_NamedField _key (sem_MExpr _value) (sem_FieldSep _sep))+sem_Field (UnnamedField _value _sep) =+    (sem_Field_UnnamedField (sem_MExpr _value) (sem_FieldSep _sep))+-- semantic domain+type T_Field = ([MToken]) ->+               Int ->+               PrettyPrintConfig ->+               ( Bool,([MToken]),Field,Bool,Bool,Region,Doc)+data Inh_Field = Inh_Field {comments_Inh_Field :: ([MToken]),indent_Inh_Field :: Int,ppconf_Inh_Field :: PrettyPrintConfig}+data Syn_Field = Syn_Field {canFitOnSameLine_Syn_Field :: Bool,comments_Syn_Field :: ([MToken]),copy_Syn_Field :: Field,isMultiline_Syn_Field :: Bool,isSemiColon_Syn_Field :: Bool,pos_Syn_Field :: Region,pretty_Syn_Field :: Doc}+wrap_Field :: T_Field ->+              Inh_Field ->+              Syn_Field+wrap_Field sem (Inh_Field _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcanFitOnSameLine,_lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOisSemiColon,_lhsOpos,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_Field _lhsOcanFitOnSameLine _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOisSemiColon _lhsOpos _lhsOpretty))+sem_Field_ExprField :: T_MExpr ->+                       T_MExpr ->+                       T_FieldSep ->+                       T_Field+sem_Field_ExprField key_ value_ sep_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisMultiline :: Bool+              _lhsOcanFitOnSameLine :: Bool+              _keyOparentOperatorPrecedence :: OperatorLevel+              _keyOparentOperatorAssociative :: Bool+              _valueOparentOperatorPrecedence :: OperatorLevel+              _valueOparentOperatorAssociative :: Bool+              _lhsOisSemiColon :: Bool+              _lhsOcopy :: Field+              _lhsOcomments :: ([MToken])+              _lhsOpos :: Region+              _keyOcomments :: ([MToken])+              _keyOindent :: Int+              _keyOppconf :: PrettyPrintConfig+              _valueOcomments :: ([MToken])+              _valueOindent :: Int+              _valueOppconf :: PrettyPrintConfig+              _sepOindent :: Int+              _sepOppconf :: PrettyPrintConfig+              _keyIcomments :: ([MToken])+              _keyIcopy :: MExpr+              _keyIisAssociative :: Bool+              _keyIisLiteral :: Bool+              _keyIisMultiline :: Bool+              _keyIpos :: Region+              _keyIprecedence :: OperatorLevel+              _keyIpretty :: Doc+              _keyIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _valueIcomments :: ([MToken])+              _valueIcopy :: MExpr+              _valueIisAssociative :: Bool+              _valueIisLiteral :: Bool+              _valueIisMultiline :: Bool+              _valueIpos :: Region+              _valueIprecedence :: OperatorLevel+              _valueIpretty :: Doc+              _valueIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _sepIcanFitOnSameLine :: Bool+              _sepIcopy :: FieldSep+              _sepIisMultiline :: Bool+              _sepIisSemiColon :: Bool+              _sepIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 673 "src/GLua/AG/PrettyPrint.ag" #-}+                   brackets _lhsIppconf _keyIpretty <-> zchr '=' <-> _valueIpretty <> _sepIpretty+                   {-# LINE 3551 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 674 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 3556 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcanFitOnSameLine =+                  ({-# LINE 675 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 3561 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _keyOparentOperatorPrecedence =+                  ({-# LINE 676 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 3566 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _keyOparentOperatorAssociative =+                  ({-# LINE 677 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 3571 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOparentOperatorPrecedence =+                  ({-# LINE 678 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 3576 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOparentOperatorAssociative =+                  ({-# LINE 679 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 3581 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisSemiColon =+                  ({-# LINE 280 "src/GLua/AG/PrettyPrint.ag" #-}+                   _sepIisSemiColon+                   {-# LINE 3586 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ExprField _keyIcopy _valueIcopy _sepIcopy+                   {-# LINE 3591 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 3596 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valueIcomments+                   {-# LINE 3601 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 271 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valueIpos+                   {-# LINE 3606 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _keyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 3611 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _keyOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3616 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _keyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3621 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _keyIcomments+                   {-# LINE 3626 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3631 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3636 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _sepOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3641 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _sepOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3646 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _keyIcomments,_keyIcopy,_keyIisAssociative,_keyIisLiteral,_keyIisMultiline,_keyIpos,_keyIprecedence,_keyIpretty,_keyIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  key_ _keyOcomments _keyOindent _keyOparentOperatorAssociative _keyOparentOperatorPrecedence _keyOppconf+              ( _valueIcomments,_valueIcopy,_valueIisAssociative,_valueIisLiteral,_valueIisMultiline,_valueIpos,_valueIprecedence,_valueIpretty,_valueIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  value_ _valueOcomments _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf+              ( _sepIcanFitOnSameLine,_sepIcopy,_sepIisMultiline,_sepIisSemiColon,_sepIpretty) =+                  sep_ _sepOindent _sepOppconf+          in  ( _lhsOcanFitOnSameLine,_lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOisSemiColon,_lhsOpos,_lhsOpretty)))+sem_Field_NamedField :: MToken ->+                        T_MExpr ->+                        T_FieldSep ->+                        T_Field+sem_Field_NamedField key_ value_ sep_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisMultiline :: Bool+              _lhsOcanFitOnSameLine :: Bool+              _valueOparentOperatorPrecedence :: OperatorLevel+              _valueOparentOperatorAssociative :: Bool+              _lhsOisSemiColon :: Bool+              _lhsOcopy :: Field+              _lhsOcomments :: ([MToken])+              _lhsOpos :: Region+              _valueOcomments :: ([MToken])+              _valueOindent :: Int+              _valueOppconf :: PrettyPrintConfig+              _sepOindent :: Int+              _sepOppconf :: PrettyPrintConfig+              _valueIcomments :: ([MToken])+              _valueIcopy :: MExpr+              _valueIisAssociative :: Bool+              _valueIisLiteral :: Bool+              _valueIisMultiline :: Bool+              _valueIpos :: Region+              _valueIprecedence :: OperatorLevel+              _valueIpretty :: Doc+              _valueIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _sepIcanFitOnSameLine :: Bool+              _sepIcopy :: FieldSep+              _sepIisMultiline :: Bool+              _sepIisSemiColon :: Bool+              _sepIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 680 "src/GLua/AG/PrettyPrint.ag" #-}+                   tok key_ <-> zchr '=' <-> _valueIpretty <> _sepIpretty+                   {-# LINE 3694 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 681 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 3699 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcanFitOnSameLine =+                  ({-# LINE 682 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 3704 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOparentOperatorPrecedence =+                  ({-# LINE 683 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 3709 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOparentOperatorAssociative =+                  ({-# LINE 684 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 3714 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisSemiColon =+                  ({-# LINE 280 "src/GLua/AG/PrettyPrint.ag" #-}+                   _sepIisSemiColon+                   {-# LINE 3719 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   NamedField key_ _valueIcopy _sepIcopy+                   {-# LINE 3724 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 3729 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valueIcomments+                   {-# LINE 3734 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 271 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valueIpos+                   {-# LINE 3739 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 3744 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3749 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3754 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _sepOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3759 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _sepOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3764 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _valueIcomments,_valueIcopy,_valueIisAssociative,_valueIisLiteral,_valueIisMultiline,_valueIpos,_valueIprecedence,_valueIpretty,_valueIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  value_ _valueOcomments _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf+              ( _sepIcanFitOnSameLine,_sepIcopy,_sepIisMultiline,_sepIisSemiColon,_sepIpretty) =+                  sep_ _sepOindent _sepOppconf+          in  ( _lhsOcanFitOnSameLine,_lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOisSemiColon,_lhsOpos,_lhsOpretty)))+sem_Field_UnnamedField :: T_MExpr ->+                          T_FieldSep ->+                          T_Field+sem_Field_UnnamedField value_ sep_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOcanFitOnSameLine :: Bool+              _valueOparentOperatorPrecedence :: OperatorLevel+              _valueOparentOperatorAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOisSemiColon :: Bool+              _lhsOcopy :: Field+              _lhsOcomments :: ([MToken])+              _lhsOpos :: Region+              _valueOcomments :: ([MToken])+              _valueOindent :: Int+              _valueOppconf :: PrettyPrintConfig+              _sepOindent :: Int+              _sepOppconf :: PrettyPrintConfig+              _valueIcomments :: ([MToken])+              _valueIcopy :: MExpr+              _valueIisAssociative :: Bool+              _valueIisLiteral :: Bool+              _valueIisMultiline :: Bool+              _valueIpos :: Region+              _valueIprecedence :: OperatorLevel+              _valueIpretty :: Doc+              _valueIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _sepIcanFitOnSameLine :: Bool+              _sepIcopy :: FieldSep+              _sepIisMultiline :: Bool+              _sepIisSemiColon :: Bool+              _sepIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 685 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valueIpretty <> _sepIpretty+                   {-# LINE 3809 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcanFitOnSameLine =+                  ({-# LINE 686 "src/GLua/AG/PrettyPrint.ag" #-}+                   _sepIcanFitOnSameLine && not _valueIisMultiline+                   {-# LINE 3814 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOparentOperatorPrecedence =+                  ({-# LINE 687 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 3819 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOparentOperatorAssociative =+                  ({-# LINE 688 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 3824 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valueIisMultiline || _sepIisMultiline+                   {-# LINE 3829 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisSemiColon =+                  ({-# LINE 280 "src/GLua/AG/PrettyPrint.ag" #-}+                   _sepIisSemiColon+                   {-# LINE 3834 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   UnnamedField _valueIcopy _sepIcopy+                   {-# LINE 3839 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 3844 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valueIcomments+                   {-# LINE 3849 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 271 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valueIpos+                   {-# LINE 3854 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 3859 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3864 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valueOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3869 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _sepOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 3874 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _sepOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 3879 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _valueIcomments,_valueIcopy,_valueIisAssociative,_valueIisLiteral,_valueIisMultiline,_valueIpos,_valueIprecedence,_valueIpretty,_valueIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  value_ _valueOcomments _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf+              ( _sepIcanFitOnSameLine,_sepIcopy,_sepIisMultiline,_sepIisSemiColon,_sepIpretty) =+                  sep_ _sepOindent _sepOppconf+          in  ( _lhsOcanFitOnSameLine,_lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOisSemiColon,_lhsOpos,_lhsOpretty)))+-- FieldList ---------------------------------------------------+-- cata+sem_FieldList :: FieldList ->+                 T_FieldList+sem_FieldList list =+    (Prelude.foldr sem_FieldList_Cons sem_FieldList_Nil (Prelude.map sem_Field list))+-- semantic domain+type T_FieldList = ([MToken]) ->+                   Int ->+                   PrettyPrintConfig ->+                   ( Bool,([MToken]),FieldList,Bool,Bool,Doc)+data Inh_FieldList = Inh_FieldList {comments_Inh_FieldList :: ([MToken]),indent_Inh_FieldList :: Int,ppconf_Inh_FieldList :: PrettyPrintConfig}+data Syn_FieldList = Syn_FieldList {canFitOnSameLine_Syn_FieldList :: Bool,comments_Syn_FieldList :: ([MToken]),copy_Syn_FieldList :: FieldList,isMultiline_Syn_FieldList :: Bool,isNil_Syn_FieldList :: Bool,pretty_Syn_FieldList :: Doc}+wrap_FieldList :: T_FieldList ->+                  Inh_FieldList ->+                  Syn_FieldList+wrap_FieldList sem (Inh_FieldList _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcanFitOnSameLine,_lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOisNil,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_FieldList _lhsOcanFitOnSameLine _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOisNil _lhsOpretty))+sem_FieldList_Cons :: T_Field ->+                      T_FieldList ->+                      T_FieldList+sem_FieldList_Cons hd_ tl_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOcanFitOnSameLine :: Bool+              _lhsOisNil :: Bool+              _hdOcomments :: ([MToken])+              _lhsOisMultiline :: Bool+              _lhsOcopy :: FieldList+              _lhsOcomments :: ([MToken])+              _hdOindent :: Int+              _hdOppconf :: PrettyPrintConfig+              _tlOcomments :: ([MToken])+              _tlOindent :: Int+              _tlOppconf :: PrettyPrintConfig+              _hdIcanFitOnSameLine :: Bool+              _hdIcomments :: ([MToken])+              _hdIcopy :: Field+              _hdIisMultiline :: Bool+              _hdIisSemiColon :: Bool+              _hdIpos :: Region+              _hdIpretty :: Doc+              _tlIcanFitOnSameLine :: Bool+              _tlIcomments :: ([MToken])+              _tlIcopy :: FieldList+              _tlIisMultiline :: Bool+              _tlIisNil :: Bool+              _tlIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 363 "src/GLua/AG/PrettyPrint.ag" #-}+                   _prettyCommentsBefore     $+$ _indentAfterComment     (_hdIpretty <-> _prettyCommentsAfter    ) `_sep    ` _ind     _tlIpretty+                   {-# LINE 3940 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcanFitOnSameLine =+                  ({-# LINE 364 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIcanFitOnSameLine+                   {-# LINE 3945 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisNil =+                  ({-# LINE 365 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 3950 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOcomments =+                  ({-# LINE 367 "src/GLua/AG/PrettyPrint.ag" #-}+                   snd _commentsAfter+                   {-# LINE 3955 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _sep =+                  ({-# LINE 369 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _onSameLine     then _optionalSpaceAfterSep     else ($+$)+                   {-# LINE 3960 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _ind =+                  ({-# LINE 370 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _onSameLine     then id else indent _lhsIppconf _lhsIindent+                   {-# LINE 3965 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _onSameLine =+                  ({-# LINE 371 "src/GLua/AG/PrettyPrint.ag" #-}+                   (_hdIcanFitOnSameLine || _tlIisNil) && null (fst _commentsAfter    )+                   {-# LINE 3970 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _optionalSpaceAfterSep =+                  ({-# LINE 373 "src/GLua/AG/PrettyPrint.ag" #-}+                   if spaceAfterComma _lhsIppconf then (<->) else (<>)+                   {-# LINE 3975 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _indentAfterComment =+                  ({-# LINE 374 "src/GLua/AG/PrettyPrint.ag" #-}+                   if null $ fst _commentsBefore     then id else indent _lhsIppconf _lhsIindent+                   {-# LINE 3980 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _isMultiline =+                  ({-# LINE 376 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisMultiline || _tlIisMultiline+                   {-# LINE 3985 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyCommentsBefore =+                  ({-# LINE 378 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderSLComments _lhsIppconf _lhsIindent (fst _commentsBefore    )+                   {-# LINE 3990 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyCommentsAfter =+                  ({-# LINE 379 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter    )+                   {-# LINE 3995 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _commentsBefore =+                  ({-# LINE 380 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _isMultiline     then+                       span (\(MToken pos _) -> pos `before` _hdIpos) _lhsIcomments+                   else+                       ([], _lhsIcomments)+                   {-# LINE 4003 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _commentsAfter =+                  ({-# LINE 386 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _isMultiline     then+                       span (\(MToken pos _) -> pos `beforeOrOnLine` _hdIpos) (snd _commentsBefore    )+                   else+                       _commentsBefore+                   {-# LINE 4011 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _isMultiline+                   {-# LINE 4016 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   (:) _hdIcopy _tlIcopy+                   {-# LINE 4021 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4026 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIcomments+                   {-# LINE 4031 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 4036 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 4041 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIcomments+                   {-# LINE 4046 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 4051 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 4056 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _hdIcanFitOnSameLine,_hdIcomments,_hdIcopy,_hdIisMultiline,_hdIisSemiColon,_hdIpos,_hdIpretty) =+                  hd_ _hdOcomments _hdOindent _hdOppconf+              ( _tlIcanFitOnSameLine,_tlIcomments,_tlIcopy,_tlIisMultiline,_tlIisNil,_tlIpretty) =+                  tl_ _tlOcomments _tlOindent _tlOppconf+          in  ( _lhsOcanFitOnSameLine,_lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOisNil,_lhsOpretty)))+sem_FieldList_Nil :: T_FieldList+sem_FieldList_Nil =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisNil :: Bool+              _lhsOcanFitOnSameLine :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: FieldList+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 391 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 4077 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisNil =+                  ({-# LINE 392 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 4082 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcanFitOnSameLine =+                  ({-# LINE 393 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 4087 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4092 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   []+                   {-# LINE 4097 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4102 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 4107 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcanFitOnSameLine,_lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOisNil,_lhsOpretty)))+-- FieldSep ----------------------------------------------------+-- cata+sem_FieldSep :: FieldSep ->+                T_FieldSep+sem_FieldSep (CommaSep) =+    (sem_FieldSep_CommaSep)+sem_FieldSep (SemicolonSep) =+    (sem_FieldSep_SemicolonSep)+sem_FieldSep (NoSep) =+    (sem_FieldSep_NoSep)+-- semantic domain+type T_FieldSep = Int ->+                  PrettyPrintConfig ->+                  ( Bool,FieldSep,Bool,Bool,Doc)+data Inh_FieldSep = Inh_FieldSep {indent_Inh_FieldSep :: Int,ppconf_Inh_FieldSep :: PrettyPrintConfig}+data Syn_FieldSep = Syn_FieldSep {canFitOnSameLine_Syn_FieldSep :: Bool,copy_Syn_FieldSep :: FieldSep,isMultiline_Syn_FieldSep :: Bool,isSemiColon_Syn_FieldSep :: Bool,pretty_Syn_FieldSep :: Doc}+wrap_FieldSep :: T_FieldSep ->+                 Inh_FieldSep ->+                 Syn_FieldSep+wrap_FieldSep sem (Inh_FieldSep _lhsIindent _lhsIppconf) =+    (let ( _lhsOcanFitOnSameLine,_lhsOcopy,_lhsOisMultiline,_lhsOisSemiColon,_lhsOpretty) = sem _lhsIindent _lhsIppconf+     in  (Syn_FieldSep _lhsOcanFitOnSameLine _lhsOcopy _lhsOisMultiline _lhsOisSemiColon _lhsOpretty))+sem_FieldSep_CommaSep :: T_FieldSep+sem_FieldSep_CommaSep =+    (\ _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOcanFitOnSameLine :: Bool+              _lhsOisMultiline :: Bool+              _lhsOisSemiColon :: Bool+              _lhsOcopy :: FieldSep+              _lhsOpretty =+                  ({-# LINE 691 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ','+                   {-# LINE 4144 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcanFitOnSameLine =+                  ({-# LINE 692 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 4149 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4154 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisSemiColon =+                  ({-# LINE 280 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4159 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   CommaSep+                   {-# LINE 4164 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4169 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcanFitOnSameLine,_lhsOcopy,_lhsOisMultiline,_lhsOisSemiColon,_lhsOpretty)))+sem_FieldSep_SemicolonSep :: T_FieldSep+sem_FieldSep_SemicolonSep =+    (\ _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisSemiColon :: Bool+              _lhsOcanFitOnSameLine :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: FieldSep+              _lhsOpretty =+                  ({-# LINE 693 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ';'+                   {-# LINE 4184 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisSemiColon =+                  ({-# LINE 694 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 4189 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcanFitOnSameLine =+                  ({-# LINE 697 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4194 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 698 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 4199 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   SemicolonSep+                   {-# LINE 4204 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4209 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcanFitOnSameLine,_lhsOcopy,_lhsOisMultiline,_lhsOisSemiColon,_lhsOpretty)))+sem_FieldSep_NoSep :: T_FieldSep+sem_FieldSep_NoSep =+    (\ _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOcanFitOnSameLine :: Bool+              _lhsOisMultiline :: Bool+              _lhsOisSemiColon :: Bool+              _lhsOcopy :: FieldSep+              _lhsOpretty =+                  ({-# LINE 699 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 4224 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcanFitOnSameLine =+                  ({-# LINE 700 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 4229 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4234 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisSemiColon =+                  ({-# LINE 280 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4239 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   NoSep+                   {-# LINE 4244 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4249 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcanFitOnSameLine,_lhsOcopy,_lhsOisMultiline,_lhsOisSemiColon,_lhsOpretty)))+-- FuncName ----------------------------------------------------+-- cata+sem_FuncName :: FuncName ->+                T_FuncName+sem_FuncName (FuncName _names _meta) =+    (sem_FuncName_FuncName _names _meta)+-- semantic domain+type T_FuncName = ([MToken]) ->+                  Int ->+                  PrettyPrintConfig ->+                  ( ([MToken]),FuncName,Bool,Doc)+data Inh_FuncName = Inh_FuncName {comments_Inh_FuncName :: ([MToken]),indent_Inh_FuncName :: Int,ppconf_Inh_FuncName :: PrettyPrintConfig}+data Syn_FuncName = Syn_FuncName {comments_Syn_FuncName :: ([MToken]),copy_Syn_FuncName :: FuncName,isMultiline_Syn_FuncName :: Bool,pretty_Syn_FuncName :: Doc}+wrap_FuncName :: T_FuncName ->+                 Inh_FuncName ->+                 Syn_FuncName+wrap_FuncName sem (Inh_FuncName _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_FuncName _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty))+sem_FuncName_FuncName :: ([MToken]) ->+                         (Maybe MToken) ->+                         T_FuncName+sem_FuncName_FuncName names_ meta_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisMultiline :: Bool+              _lhsOcopy :: FuncName+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 567 "src/GLua/AG/PrettyPrint.ag" #-}+                   printList tok "." names_ <> metaDoc meta_+                   {-# LINE 4285 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4290 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   FuncName names_ meta_+                   {-# LINE 4295 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4300 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 4305 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+-- MElse -------------------------------------------------------+-- cata+sem_MElse :: MElse ->+             T_MElse+sem_MElse (MElse _pos _body) =+    (sem_MElse_MElse _pos (sem_Block _body))+-- semantic domain+type T_MElse = ([MToken]) ->+               Int ->+               PrettyPrintConfig ->+               Region ->+               ( ([MToken]),MElse,Bool,Bool,Region,Doc)+data Inh_MElse = Inh_MElse {comments_Inh_MElse :: ([MToken]),indent_Inh_MElse :: Int,ppconf_Inh_MElse :: PrettyPrintConfig,statRegion_Inh_MElse :: Region}+data Syn_MElse = Syn_MElse {comments_Syn_MElse :: ([MToken]),copy_Syn_MElse :: MElse,elsesExist_Syn_MElse :: Bool,isMultiline_Syn_MElse :: Bool,pos_Syn_MElse :: Region,pretty_Syn_MElse :: Doc}+wrap_MElse :: T_MElse ->+              Inh_MElse ->+              Syn_MElse+wrap_MElse sem (Inh_MElse _lhsIcomments _lhsIindent _lhsIppconf _lhsIstatRegion) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOelsesExist,_lhsOisMultiline,_lhsOpos,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf _lhsIstatRegion+     in  (Syn_MElse _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty))+sem_MElse_MElse :: Region ->+                   T_Block ->+                   T_MElse+sem_MElse_MElse pos_ body_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _bodyOindent :: Int+              _lhsOpos :: Region+              _bodyOcomments :: ([MToken])+              _lhsOelsesExist :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: MElse+              _lhsOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _lhsOpretty =+                  ({-# LINE 448 "src/GLua/AG/PrettyPrint.ag" #-}+                   indent _lhsIppconf _lhsIindent (zeroWidthText "else") <-> _prettyCommentsAfter     $+$ _bodyIpretty+                   {-# LINE 4355 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 449 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 4360 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyCommentsAfter =+                  ({-# LINE 450 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter    )+                   {-# LINE 4365 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _commentsAfter =+                  ({-# LINE 451 "src/GLua/AG/PrettyPrint.ag" #-}+                   span (\(MToken pos _) -> pos `beforeOrOnLine` pos_) _lhsIcomments+                   {-# LINE 4370 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 452 "src/GLua/AG/PrettyPrint.ag" #-}+                   pos_+                   {-# LINE 4375 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 453 "src/GLua/AG/PrettyPrint.ag" #-}+                   snd _commentsAfter+                   {-# LINE 4380 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOelsesExist =+                  ({-# LINE 293 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4385 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIisMultiline+                   {-# LINE 4390 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   MElse pos_ _bodyIcopy+                   {-# LINE 4395 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4400 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 4405 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 4410 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 4415 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOelsesExist,_lhsOisMultiline,_lhsOpos,_lhsOpretty)))+-- MElseIf -----------------------------------------------------+-- cata+sem_MElseIf :: MElseIf ->+               T_MElseIf+sem_MElseIf (MElseIf _pos _elif) =+    (sem_MElseIf_MElseIf _pos (sem_ElseIf _elif))+-- semantic domain+type T_MElseIf = ([MToken]) ->+                 Int ->+                 PrettyPrintConfig ->+                 ( ([MToken]),MElseIf,Bool,Region,Doc)+data Inh_MElseIf = Inh_MElseIf {comments_Inh_MElseIf :: ([MToken]),indent_Inh_MElseIf :: Int,ppconf_Inh_MElseIf :: PrettyPrintConfig}+data Syn_MElseIf = Syn_MElseIf {comments_Syn_MElseIf :: ([MToken]),copy_Syn_MElseIf :: MElseIf,isMultiline_Syn_MElseIf :: Bool,pos_Syn_MElseIf :: Region,pretty_Syn_MElseIf :: Doc}+wrap_MElseIf :: T_MElseIf ->+                Inh_MElseIf ->+                Syn_MElseIf+wrap_MElseIf sem (Inh_MElseIf _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpos,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_MElseIf _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpos _lhsOpretty))+sem_MElseIf_MElseIf :: Region ->+                       T_ElseIf ->+                       T_MElseIf+sem_MElseIf_MElseIf pos_ elif_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpos :: Region+              _lhsOisMultiline :: Bool+              _lhsOcopy :: MElseIf+              _lhsOcomments :: ([MToken])+              _lhsOpretty :: Doc+              _elifOcomments :: ([MToken])+              _elifOindent :: Int+              _elifOppconf :: PrettyPrintConfig+              _elifIcomments :: ([MToken])+              _elifIcopy :: ElseIf+              _elifIisMultiline :: Bool+              _elifIpretty :: Doc+              _lhsOpos =+                  ({-# LINE 433 "src/GLua/AG/PrettyPrint.ag" #-}+                   pos_+                   {-# LINE 4461 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _elifIisMultiline+                   {-# LINE 4466 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   MElseIf pos_ _elifIcopy+                   {-# LINE 4471 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4476 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _elifIcomments+                   {-# LINE 4481 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 232 "src/GLua/AG/PrettyPrint.ag" #-}+                   _elifIpretty+                   {-# LINE 4486 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elifOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 4491 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elifOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 4496 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elifOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 4501 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _elifIcomments,_elifIcopy,_elifIisMultiline,_elifIpretty) =+                  elif_ _elifOcomments _elifOindent _elifOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpos,_lhsOpretty)))+-- MExpr -------------------------------------------------------+-- cata+sem_MExpr :: MExpr ->+             T_MExpr+sem_MExpr (MExpr _pos _expr) =+    (sem_MExpr_MExpr _pos (sem_Expr _expr))+-- semantic domain+type T_MExpr = ([MToken]) ->+               Int ->+               Bool ->+               OperatorLevel ->+               PrettyPrintConfig ->+               ( ([MToken]),MExpr,Bool,Bool,Bool,Region,OperatorLevel,Doc,Bool)+data Inh_MExpr = Inh_MExpr {comments_Inh_MExpr :: ([MToken]),indent_Inh_MExpr :: Int,parentOperatorAssociative_Inh_MExpr :: Bool,parentOperatorPrecedence_Inh_MExpr :: OperatorLevel,ppconf_Inh_MExpr :: PrettyPrintConfig}+data Syn_MExpr = Syn_MExpr {comments_Syn_MExpr :: ([MToken]),copy_Syn_MExpr :: MExpr,isAssociative_Syn_MExpr :: Bool,isLiteral_Syn_MExpr :: Bool,isMultiline_Syn_MExpr :: Bool,pos_Syn_MExpr :: Region,precedence_Syn_MExpr :: OperatorLevel,pretty_Syn_MExpr :: Doc,wouldBeAmbiguousIfNextStatementIsExprVar_Syn_MExpr :: Bool}+wrap_MExpr :: T_MExpr ->+              Inh_MExpr ->+              Syn_MExpr+wrap_MExpr sem (Inh_MExpr _lhsIcomments _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOpos,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar) = sem _lhsIcomments _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf+     in  (Syn_MExpr _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOpos _lhsOprecedence _lhsOpretty _lhsOwouldBeAmbiguousIfNextStatementIsExprVar))+sem_MExpr_MExpr :: Region ->+                   T_Expr ->+                   T_MExpr+sem_MExpr_MExpr pos_ expr_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf ->+         (let _lhsOpos :: Region+              _exprOstatRegion :: Region+              _lhsOisAssociative :: Bool+              _lhsOisLiteral :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: MExpr+              _lhsOcomments :: ([MToken])+              _lhsOpretty :: Doc+              _exprOcomments :: ([MToken])+              _exprOindent :: Int+              _exprOparentOperatorAssociative :: Bool+              _exprOparentOperatorPrecedence :: OperatorLevel+              _exprOppconf :: PrettyPrintConfig+              _exprIcomments :: ([MToken])+              _exprIcopy :: Expr+              _exprIisAssociative :: Bool+              _exprIisLiteral :: Bool+              _exprIisMultiline :: Bool+              _exprIprecedence :: OperatorLevel+              _exprIpretty :: Doc+              _exprIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpos =+                  ({-# LINE 616 "src/GLua/AG/PrettyPrint.ag" #-}+                   pos_+                   {-# LINE 4562 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOstatRegion =+                  ({-# LINE 617 "src/GLua/AG/PrettyPrint.ag" #-}+                   pos_+                   {-# LINE 4567 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIisAssociative+                   {-# LINE 4572 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 246 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIisLiteral+                   {-# LINE 4577 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIisMultiline+                   {-# LINE 4582 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIprecedence+                   {-# LINE 4587 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIwouldBeAmbiguousIfNextStatementIsExprVar+                   {-# LINE 4592 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   MExpr pos_ _exprIcopy+                   {-# LINE 4597 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4602 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIcomments+                   {-# LINE 4607 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 232 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIpretty+                   {-# LINE 4612 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 4617 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 4622 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOparentOperatorAssociative =+                  ({-# LINE 243 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIparentOperatorAssociative+                   {-# LINE 4627 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOparentOperatorPrecedence =+                  ({-# LINE 242 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIparentOperatorPrecedence+                   {-# LINE 4632 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 4637 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _exprIcomments,_exprIcopy,_exprIisAssociative,_exprIisLiteral,_exprIisMultiline,_exprIprecedence,_exprIpretty,_exprIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  expr_ _exprOcomments _exprOindent _exprOparentOperatorAssociative _exprOparentOperatorPrecedence _exprOppconf _exprOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOpos,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+-- MExprList ---------------------------------------------------+-- cata+sem_MExprList :: MExprList ->+                 T_MExprList+sem_MExprList list =+    (Prelude.foldr sem_MExprList_Cons sem_MExprList_Nil (Prelude.map sem_MExpr list))+-- semantic domain+type T_MExprList = ([MToken]) ->+                   Int ->+                   Bool ->+                   PrettyPrintConfig ->+                   ( ([MToken]),MExprList,Bool,Bool,Region,OperatorLevel,Doc)+data Inh_MExprList = Inh_MExprList {comments_Inh_MExprList :: ([MToken]),indent_Inh_MExprList :: Int,isHead_Inh_MExprList :: Bool,ppconf_Inh_MExprList :: PrettyPrintConfig}+data Syn_MExprList = Syn_MExprList {comments_Syn_MExprList :: ([MToken]),copy_Syn_MExprList :: MExprList,isAssociative_Syn_MExprList :: Bool,isMultiline_Syn_MExprList :: Bool,pos_Syn_MExprList :: Region,precedence_Syn_MExprList :: OperatorLevel,pretty_Syn_MExprList :: Doc}+wrap_MExprList :: T_MExprList ->+                  Inh_MExprList ->+                  Syn_MExprList+wrap_MExprList sem (Inh_MExprList _lhsIcomments _lhsIindent _lhsIisHead _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOpos,_lhsOprecedence,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIisHead _lhsIppconf+     in  (Syn_MExprList _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOpos _lhsOprecedence _lhsOpretty))+sem_MExprList_Cons :: T_MExpr ->+                      T_MExprList ->+                      T_MExprList+sem_MExprList_Cons hd_ tl_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisHead+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _tlOisHead :: Bool+              _lhsOpos :: Region+              _hdOparentOperatorPrecedence :: OperatorLevel+              _hdOparentOperatorAssociative :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: MExprList+              _lhsOcomments :: ([MToken])+              _hdOcomments :: ([MToken])+              _hdOindent :: Int+              _hdOppconf :: PrettyPrintConfig+              _tlOcomments :: ([MToken])+              _tlOindent :: Int+              _tlOppconf :: PrettyPrintConfig+              _hdIcomments :: ([MToken])+              _hdIcopy :: MExpr+              _hdIisAssociative :: Bool+              _hdIisLiteral :: Bool+              _hdIisMultiline :: Bool+              _hdIpos :: Region+              _hdIprecedence :: OperatorLevel+              _hdIpretty :: Doc+              _hdIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _tlIcomments :: ([MToken])+              _tlIcopy :: MExprList+              _tlIisAssociative :: Bool+              _tlIisMultiline :: Bool+              _tlIpos :: Region+              _tlIprecedence :: OperatorLevel+              _tlIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 353 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if _lhsIisHead then empty else _comma    ) <> _hdIpretty <> _tlIpretty+                   {-# LINE 4705 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _comma =+                  ({-# LINE 354 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ',' <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)+                   {-# LINE 4710 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOisHead =+                  ({-# LINE 355 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4715 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 356 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIpos+                   {-# LINE 4720 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOparentOperatorPrecedence =+                  ({-# LINE 357 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 4725 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOparentOperatorAssociative =+                  ({-# LINE 358 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 4730 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisAssociative && _tlIisAssociative+                   {-# LINE 4735 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisMultiline || _tlIisMultiline+                   {-# LINE 4740 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   (min _hdIprecedence _tlIprecedence)+                   {-# LINE 4745 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   (:) _hdIcopy _tlIcopy+                   {-# LINE 4750 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4755 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIcomments+                   {-# LINE 4760 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 4765 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 4770 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 4775 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIcomments+                   {-# LINE 4780 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 4785 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 4790 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _hdIcomments,_hdIcopy,_hdIisAssociative,_hdIisLiteral,_hdIisMultiline,_hdIpos,_hdIprecedence,_hdIpretty,_hdIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  hd_ _hdOcomments _hdOindent _hdOparentOperatorAssociative _hdOparentOperatorPrecedence _hdOppconf+              ( _tlIcomments,_tlIcopy,_tlIisAssociative,_tlIisMultiline,_tlIpos,_tlIprecedence,_tlIpretty) =+                  tl_ _tlOcomments _tlOindent _tlOisHead _tlOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOpos,_lhsOprecedence,_lhsOpretty)))+sem_MExprList_Nil :: T_MExprList+sem_MExprList_Nil =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisHead+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOpos :: Region+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: MExprList+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 359 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 4813 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpos =+                  ({-# LINE 360 "src/GLua/AG/PrettyPrint.ag" #-}+                   emptyRg+                   {-# LINE 4818 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4823 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 4828 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 4833 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   []+                   {-# LINE 4838 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4843 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 4848 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOpos,_lhsOprecedence,_lhsOpretty)))+-- MStat -------------------------------------------------------+-- cata+sem_MStat :: MStat ->+             T_MStat+sem_MStat (MStat _pos _stat) =+    (sem_MStat_MStat _pos (sem_Stat _stat))+-- semantic domain+type T_MStat = ([MToken]) ->+               Int ->+               Bool ->+               Bool ->+               PrettyPrintConfig ->+               ( ([MToken]),MStat,Bool,Bool,Region,Bool,Doc,Int)+data Inh_MStat = Inh_MStat {comments_Inh_MStat :: ([MToken]),indent_Inh_MStat :: Int,isLastStatement_Inh_MStat :: Bool,potentiallyAmbiguousAsStatement_Inh_MStat :: Bool,ppconf_Inh_MStat :: PrettyPrintConfig}+data Syn_MStat = Syn_MStat {comments_Syn_MStat :: ([MToken]),copy_Syn_MStat :: MStat,hasBreaking_Syn_MStat :: Bool,isMultiline_Syn_MStat :: Bool,pos_Syn_MStat :: Region,potentiallyAmbiguousAsStatement_Syn_MStat :: Bool,pretty_Syn_MStat :: Doc,statementCount_Syn_MStat :: Int}+wrap_MStat :: T_MStat ->+              Inh_MStat ->+              Syn_MStat+wrap_MStat sem (Inh_MStat _lhsIcomments _lhsIindent _lhsIisLastStatement _lhsIpotentiallyAmbiguousAsStatement _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpos,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty,_lhsOstatementCount) = sem _lhsIcomments _lhsIindent _lhsIisLastStatement _lhsIpotentiallyAmbiguousAsStatement _lhsIppconf+     in  (Syn_MStat _lhsOcomments _lhsOcopy _lhsOhasBreaking _lhsOisMultiline _lhsOpos _lhsOpotentiallyAmbiguousAsStatement _lhsOpretty _lhsOstatementCount))+sem_MStat_MStat :: Region ->+                   T_Stat ->+                   T_MStat+sem_MStat_MStat pos_ stat_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf ->+         (let _lhsOpos :: Region+              _statOstatRegion :: Region+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOstatementCount :: Int+              _lhsOcopy :: MStat+              _lhsOcomments :: ([MToken])+              _lhsOpretty :: Doc+              _statOcomments :: ([MToken])+              _statOindent :: Int+              _statOisLastStatement :: Bool+              _statOpotentiallyAmbiguousAsStatement :: Bool+              _statOppconf :: PrettyPrintConfig+              _statIcomments :: ([MToken])+              _statIcopy :: Stat+              _statIhasBreaking :: Bool+              _statIisMultiline :: Bool+              _statIpotentiallyAmbiguousAsStatement :: Bool+              _statIpretty :: Doc+              _lhsOpos =+                  ({-# LINE 349 "src/GLua/AG/PrettyPrint.ag" #-}+                   pos_+                   {-# LINE 4904 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statOstatRegion =+                  ({-# LINE 350 "src/GLua/AG/PrettyPrint.ag" #-}+                   pos_+                   {-# LINE 4909 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statIhasBreaking+                   {-# LINE 4914 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statIisMultiline+                   {-# LINE 4919 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statIpotentiallyAmbiguousAsStatement+                   {-# LINE 4924 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOstatementCount =+                  ({-# LINE 287 "src/GLua/AG/PrettyPrint.ag" #-}+                   1+                   {-# LINE 4929 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   MStat pos_ _statIcopy+                   {-# LINE 4934 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 4939 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statIcomments+                   {-# LINE 4944 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 232 "src/GLua/AG/PrettyPrint.ag" #-}+                   _statIpretty+                   {-# LINE 4949 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 4954 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 4959 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statOisLastStatement =+                  ({-# LINE 268 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIisLastStatement+                   {-# LINE 4964 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 304 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIpotentiallyAmbiguousAsStatement+                   {-# LINE 4969 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _statOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 4974 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _statIcomments,_statIcopy,_statIhasBreaking,_statIisMultiline,_statIpotentiallyAmbiguousAsStatement,_statIpretty) =+                  stat_ _statOcomments _statOindent _statOisLastStatement _statOpotentiallyAmbiguousAsStatement _statOppconf _statOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpos,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty,_lhsOstatementCount)))+-- MStatList ---------------------------------------------------+-- cata+sem_MStatList :: MStatList ->+                 T_MStatList+sem_MStatList list =+    (Prelude.foldr sem_MStatList_Cons sem_MStatList_Nil (Prelude.map sem_MStat list))+-- semantic domain+type T_MStatList = ([MToken]) ->+                   Int ->+                   Bool ->+                   PrettyPrintConfig ->+                   Region ->+                   ( ([MToken]),MStatList,Bool,Bool,Bool,Bool,Doc,Int)+data Inh_MStatList = Inh_MStatList {comments_Inh_MStatList :: ([MToken]),indent_Inh_MStatList :: Int,isHead_Inh_MStatList :: Bool,ppconf_Inh_MStatList :: PrettyPrintConfig,statRegion_Inh_MStatList :: Region}+data Syn_MStatList = Syn_MStatList {comments_Syn_MStatList :: ([MToken]),copy_Syn_MStatList :: MStatList,hasBreaking_Syn_MStatList :: Bool,isLast_Syn_MStatList :: Bool,isMultiline_Syn_MStatList :: Bool,potentiallyAmbiguousAsStatement_Syn_MStatList :: Bool,pretty_Syn_MStatList :: Doc,statementCount_Syn_MStatList :: Int}+wrap_MStatList :: T_MStatList ->+                  Inh_MStatList ->+                  Syn_MStatList+wrap_MStatList sem (Inh_MStatList _lhsIcomments _lhsIindent _lhsIisHead _lhsIppconf _lhsIstatRegion) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisLast,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty,_lhsOstatementCount) = sem _lhsIcomments _lhsIindent _lhsIisHead _lhsIppconf _lhsIstatRegion+     in  (Syn_MStatList _lhsOcomments _lhsOcopy _lhsOhasBreaking _lhsOisLast _lhsOisMultiline _lhsOpotentiallyAmbiguousAsStatement _lhsOpretty _lhsOstatementCount))+sem_MStatList_Cons :: T_MStat ->+                      T_MStatList ->+                      T_MStatList+sem_MStatList_Cons hd_ tl_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisHead+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOisMultiline :: Bool+              _lhsOpretty :: Doc+              _hdOcomments :: ([MToken])+              _tlOcomments :: ([MToken])+              _tlOisHead :: Bool+              _hdOisLastStatement :: Bool+              _hdOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOisLast :: Bool+              _lhsOhasBreaking :: Bool+              _lhsOstatementCount :: Int+              _lhsOcopy :: MStatList+              _lhsOcomments :: ([MToken])+              _hdOindent :: Int+              _hdOppconf :: PrettyPrintConfig+              _tlOindent :: Int+              _tlOppconf :: PrettyPrintConfig+              _tlOstatRegion :: Region+              _hdIcomments :: ([MToken])+              _hdIcopy :: MStat+              _hdIhasBreaking :: Bool+              _hdIisMultiline :: Bool+              _hdIpos :: Region+              _hdIpotentiallyAmbiguousAsStatement :: Bool+              _hdIpretty :: Doc+              _hdIstatementCount :: Int+              _tlIcomments :: ([MToken])+              _tlIcopy :: MStatList+              _tlIhasBreaking :: Bool+              _tlIisLast :: Bool+              _tlIisMultiline :: Bool+              _tlIpotentiallyAmbiguousAsStatement :: Bool+              _tlIpretty :: Doc+              _tlIstatementCount :: Int+              _lhsOisMultiline =+                  ({-# LINE 314 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisMultiline+                   {-# LINE 5046 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _addNewline =+                  ({-# LINE 315 "src/GLua/AG/PrettyPrint.ag" #-}+                   if not _tlIisLast && (_hdIisMultiline || _tlIisMultiline) then zchr '\n' else empty+                   {-# LINE 5051 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 316 "src/GLua/AG/PrettyPrint.ag" #-}+                   _prettyCommentsBefore+                   $+$ indent _lhsIppconf _lhsIindent _hdIpretty+                   <-> _prettyCommentsAfter     <> _addNewline+                   $+$ _tlIpretty+                   {-# LINE 5059 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyCommentsBefore =+                  ({-# LINE 322 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderMLComments _lhsIppconf _lhsIindent (fst _commentsBefore    )+                   {-# LINE 5064 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _prettyCommentsAfter =+                  ({-# LINE 323 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter    )+                   {-# LINE 5069 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _commentsBefore =+                  ({-# LINE 324 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _hdIisMultiline+                   then span (\(MToken pos' _) -> pos' `beforeOrOnLine` _hdIpos) _lhsIcomments+                   else span (\(MToken pos' _) -> pos' `before`         _hdIpos) _lhsIcomments+                   {-# LINE 5076 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _commentsAfter =+                  ({-# LINE 328 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _hdIisMultiline+                   then span (\(MToken pos' _) -> pos' `beforeOrOnLine` _hdIpos) (snd _commentsBefore    )+                   else span (\(MToken pos' _) -> pos' `beforeEndLine`  _hdIpos) (snd _commentsBefore    )+                   {-# LINE 5083 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOcomments =+                  ({-# LINE 332 "src/GLua/AG/PrettyPrint.ag" #-}+                   snd _commentsAfter+                   {-# LINE 5088 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOcomments =+                  ({-# LINE 333 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIcomments+                   {-# LINE 5093 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOisHead =+                  ({-# LINE 335 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5098 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOisLastStatement =+                  ({-# LINE 336 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIisLast+                   {-# LINE 5103 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 337 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIpotentiallyAmbiguousAsStatement+                   {-# LINE 5108 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 338 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIpotentiallyAmbiguousAsStatement+                   {-# LINE 5113 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLast =+                  ({-# LINE 339 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5118 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIhasBreaking || _tlIhasBreaking+                   {-# LINE 5123 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOstatementCount =+                  ({-# LINE 287 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIstatementCount + _tlIstatementCount+                   {-# LINE 5128 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   (:) _hdIcopy _tlIcopy+                   {-# LINE 5133 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5138 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIcomments+                   {-# LINE 5143 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5148 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5153 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5158 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5163 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 5168 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _hdIcomments,_hdIcopy,_hdIhasBreaking,_hdIisMultiline,_hdIpos,_hdIpotentiallyAmbiguousAsStatement,_hdIpretty,_hdIstatementCount) =+                  hd_ _hdOcomments _hdOindent _hdOisLastStatement _hdOpotentiallyAmbiguousAsStatement _hdOppconf+              ( _tlIcomments,_tlIcopy,_tlIhasBreaking,_tlIisLast,_tlIisMultiline,_tlIpotentiallyAmbiguousAsStatement,_tlIpretty,_tlIstatementCount) =+                  tl_ _tlOcomments _tlOindent _tlOisHead _tlOppconf _tlOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisLast,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty,_lhsOstatementCount)))+sem_MStatList_Nil :: T_MStatList+sem_MStatList_Nil =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisHead+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOstatementCount :: Int+              _lhsOcomments :: ([MToken])+              _lhsOhasBreaking :: Bool+              _lhsOisLast :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: MStatList+              _lhsOpretty =+                  ({-# LINE 340 "src/GLua/AG/PrettyPrint.ag" #-}+                   _renderedComments+                   {-# LINE 5193 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOstatementCount =+                  ({-# LINE 341 "src/GLua/AG/PrettyPrint.ag" #-}+                   0+                   {-# LINE 5198 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _renderedComments =+                  ({-# LINE 342 "src/GLua/AG/PrettyPrint.ag" #-}+                   renderMLComments _lhsIppconf _lhsIindent $ fst _commentsBeforeEnd+                   {-# LINE 5203 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _commentsBeforeEnd =+                  ({-# LINE 345 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _lhsIisHead then ([], _lhsIcomments) else span (\(MToken pos' _tok) -> pos' `beforeEnd` _lhsIstatRegion) _lhsIcomments+                   {-# LINE 5208 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 346 "src/GLua/AG/PrettyPrint.ag" #-}+                   snd _commentsBeforeEnd+                   {-# LINE 5213 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5218 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLast =+                  ({-# LINE 265 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 5223 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5228 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5233 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   []+                   {-# LINE 5238 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5243 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisLast,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty,_lhsOstatementCount)))+-- MaybeMExpr --------------------------------------------------+-- cata+sem_MaybeMExpr :: MaybeMExpr ->+                  T_MaybeMExpr+sem_MaybeMExpr (Prelude.Just x) =+    (sem_MaybeMExpr_Just (sem_MExpr x))+sem_MaybeMExpr Prelude.Nothing =+    sem_MaybeMExpr_Nothing+-- semantic domain+type T_MaybeMExpr = ([MToken]) ->+                    Int ->+                    PrettyPrintConfig ->+                    ( ([MToken]),MaybeMExpr,Bool,Bool,Bool,OperatorLevel,Doc,Bool)+data Inh_MaybeMExpr = Inh_MaybeMExpr {comments_Inh_MaybeMExpr :: ([MToken]),indent_Inh_MaybeMExpr :: Int,ppconf_Inh_MaybeMExpr :: PrettyPrintConfig}+data Syn_MaybeMExpr = Syn_MaybeMExpr {comments_Syn_MaybeMExpr :: ([MToken]),copy_Syn_MaybeMExpr :: MaybeMExpr,isAssociative_Syn_MaybeMExpr :: Bool,isDefined_Syn_MaybeMExpr :: Bool,isMultiline_Syn_MaybeMExpr :: Bool,precedence_Syn_MaybeMExpr :: OperatorLevel,pretty_Syn_MaybeMExpr :: Doc,wouldBeAmbiguousIfNextStatementIsExprVar_Syn_MaybeMExpr :: Bool}+wrap_MaybeMExpr :: T_MaybeMExpr ->+                   Inh_MaybeMExpr ->+                   Syn_MaybeMExpr+wrap_MaybeMExpr sem (Inh_MaybeMExpr _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisDefined,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_MaybeMExpr _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisDefined _lhsOisMultiline _lhsOprecedence _lhsOpretty _lhsOwouldBeAmbiguousIfNextStatementIsExprVar))+sem_MaybeMExpr_Just :: T_MExpr ->+                       T_MaybeMExpr+sem_MaybeMExpr_Just just_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisDefined :: Bool+              _justOparentOperatorPrecedence :: OperatorLevel+              _justOparentOperatorAssociative :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: MaybeMExpr+              _lhsOcomments :: ([MToken])+              _justOcomments :: ([MToken])+              _justOindent :: Int+              _justOppconf :: PrettyPrintConfig+              _justIcomments :: ([MToken])+              _justIcopy :: MExpr+              _justIisAssociative :: Bool+              _justIisLiteral :: Bool+              _justIisMultiline :: Bool+              _justIpos :: Region+              _justIprecedence :: OperatorLevel+              _justIpretty :: Doc+              _justIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpretty =+                  ({-# LINE 397 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIpretty+                   {-# LINE 5298 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisDefined =+                  ({-# LINE 398 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 5303 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOparentOperatorPrecedence =+                  ({-# LINE 399 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 5308 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOparentOperatorAssociative =+                  ({-# LINE 400 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 5313 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIisAssociative+                   {-# LINE 5318 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIisMultiline+                   {-# LINE 5323 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIprecedence+                   {-# LINE 5328 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIwouldBeAmbiguousIfNextStatementIsExprVar+                   {-# LINE 5333 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   Just _justIcopy+                   {-# LINE 5338 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5343 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _justIcomments+                   {-# LINE 5348 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 5353 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5358 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _justOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5363 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _justIcomments,_justIcopy,_justIisAssociative,_justIisLiteral,_justIisMultiline,_justIpos,_justIprecedence,_justIpretty,_justIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  just_ _justOcomments _justOindent _justOparentOperatorAssociative _justOparentOperatorPrecedence _justOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisDefined,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_MaybeMExpr_Nothing :: T_MaybeMExpr+sem_MaybeMExpr_Nothing =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisDefined :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: MaybeMExpr+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 402 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 5384 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisDefined =+                  ({-# LINE 403 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5389 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5394 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5399 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 5404 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5409 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   Nothing+                   {-# LINE 5414 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5419 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 5424 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisDefined,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+-- PFExprSuffix ------------------------------------------------+-- cata+sem_PFExprSuffix :: PFExprSuffix ->+                    T_PFExprSuffix+sem_PFExprSuffix (Call _args) =+    (sem_PFExprSuffix_Call (sem_Args _args))+sem_PFExprSuffix (MetaCall _fn _args) =+    (sem_PFExprSuffix_MetaCall _fn (sem_Args _args))+sem_PFExprSuffix (ExprIndex _index) =+    (sem_PFExprSuffix_ExprIndex (sem_MExpr _index))+sem_PFExprSuffix (DotIndex _index) =+    (sem_PFExprSuffix_DotIndex _index)+-- semantic domain+type T_PFExprSuffix = ([MToken]) ->+                      Int ->+                      PrettyPrintConfig ->+                      ( ([MToken]),PFExprSuffix,Bool,Bool,OperatorLevel,Doc)+data Inh_PFExprSuffix = Inh_PFExprSuffix {comments_Inh_PFExprSuffix :: ([MToken]),indent_Inh_PFExprSuffix :: Int,ppconf_Inh_PFExprSuffix :: PrettyPrintConfig}+data Syn_PFExprSuffix = Syn_PFExprSuffix {comments_Syn_PFExprSuffix :: ([MToken]),copy_Syn_PFExprSuffix :: PFExprSuffix,isAssociative_Syn_PFExprSuffix :: Bool,isMultiline_Syn_PFExprSuffix :: Bool,precedence_Syn_PFExprSuffix :: OperatorLevel,pretty_Syn_PFExprSuffix :: Doc}+wrap_PFExprSuffix :: T_PFExprSuffix ->+                     Inh_PFExprSuffix ->+                     Syn_PFExprSuffix+wrap_PFExprSuffix sem (Inh_PFExprSuffix _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_PFExprSuffix _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty))+sem_PFExprSuffix_Call :: T_Args ->+                         T_PFExprSuffix+sem_PFExprSuffix_Call args_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: PFExprSuffix+              _lhsOcomments :: ([MToken])+              _argsOcomments :: ([MToken])+              _argsOindent :: Int+              _argsOppconf :: PrettyPrintConfig+              _argsIcomments :: ([MToken])+              _argsIcopy :: Args+              _argsIisMultiline :: Bool+              _argsIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 608 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argsIpretty+                   {-# LINE 5474 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5479 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argsIisMultiline+                   {-# LINE 5484 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 5489 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   Call _argsIcopy+                   {-# LINE 5494 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5499 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argsIcomments+                   {-# LINE 5504 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 5509 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5514 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5519 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _argsIcomments,_argsIcopy,_argsIisMultiline,_argsIpretty) =+                  args_ _argsOcomments _argsOindent _argsOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_PFExprSuffix_MetaCall :: MToken ->+                             T_Args ->+                             T_PFExprSuffix+sem_PFExprSuffix_MetaCall fn_ args_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: PFExprSuffix+              _lhsOcomments :: ([MToken])+              _argsOcomments :: ([MToken])+              _argsOindent :: Int+              _argsOppconf :: PrettyPrintConfig+              _argsIcomments :: ([MToken])+              _argsIcopy :: Args+              _argsIisMultiline :: Bool+              _argsIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 609 "src/GLua/AG/PrettyPrint.ag" #-}+                   zchr ':' <> tok fn_ <> _argsIpretty+                   {-# LINE 5547 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5552 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argsIisMultiline+                   {-# LINE 5557 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 5562 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   MetaCall fn_ _argsIcopy+                   {-# LINE 5567 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5572 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _argsIcomments+                   {-# LINE 5577 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 5582 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5587 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _argsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5592 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _argsIcomments,_argsIcopy,_argsIisMultiline,_argsIpretty) =+                  args_ _argsOcomments _argsOindent _argsOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_PFExprSuffix_ExprIndex :: T_MExpr ->+                              T_PFExprSuffix+sem_PFExprSuffix_ExprIndex index_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _indexOparentOperatorPrecedence :: OperatorLevel+              _indexOparentOperatorAssociative :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: PFExprSuffix+              _lhsOcomments :: ([MToken])+              _indexOcomments :: ([MToken])+              _indexOindent :: Int+              _indexOppconf :: PrettyPrintConfig+              _indexIcomments :: ([MToken])+              _indexIcopy :: MExpr+              _indexIisAssociative :: Bool+              _indexIisLiteral :: Bool+              _indexIisMultiline :: Bool+              _indexIpos :: Region+              _indexIprecedence :: OperatorLevel+              _indexIpretty :: Doc+              _indexIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpretty =+                  ({-# LINE 610 "src/GLua/AG/PrettyPrint.ag" #-}+                   brackets _lhsIppconf _indexIpretty+                   {-# LINE 5626 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _indexOparentOperatorPrecedence =+                  ({-# LINE 611 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 5631 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _indexOparentOperatorAssociative =+                  ({-# LINE 612 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 5636 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _indexIisAssociative+                   {-# LINE 5641 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _indexIisMultiline+                   {-# LINE 5646 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   _indexIprecedence+                   {-# LINE 5651 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ExprIndex _indexIcopy+                   {-# LINE 5656 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5661 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _indexIcomments+                   {-# LINE 5666 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _indexOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 5671 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _indexOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5676 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _indexOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5681 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _indexIcomments,_indexIcopy,_indexIisAssociative,_indexIisLiteral,_indexIisMultiline,_indexIpos,_indexIprecedence,_indexIpretty,_indexIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  index_ _indexOcomments _indexOindent _indexOparentOperatorAssociative _indexOparentOperatorPrecedence _indexOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+sem_PFExprSuffix_DotIndex :: MToken ->+                             T_PFExprSuffix+sem_PFExprSuffix_DotIndex index_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: PFExprSuffix+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 613 "src/GLua/AG/PrettyPrint.ag" #-}+                   zchr '.' <> tok index_+                   {-# LINE 5701 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5706 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5711 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   OperatorLevel8+                   {-# LINE 5716 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   DotIndex index_+                   {-# LINE 5721 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5726 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 5731 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisMultiline,_lhsOprecedence,_lhsOpretty)))+-- PrefixExp ---------------------------------------------------+-- cata+sem_PrefixExp :: PrefixExp ->+                 T_PrefixExp+sem_PrefixExp (PFVar _name _suffixes) =+    (sem_PrefixExp_PFVar _name (sem_ExprSuffixList _suffixes))+sem_PrefixExp (ExprVar _expr _suffixes) =+    (sem_PrefixExp_ExprVar (sem_MExpr _expr) (sem_ExprSuffixList _suffixes))+-- semantic domain+type T_PrefixExp = ([MToken]) ->+                   Int ->+                   Bool ->+                   OperatorLevel ->+                   PrettyPrintConfig ->+                   ( ([MToken]),PrefixExp,Bool,Bool,Bool,Bool,OperatorLevel,Doc)+data Inh_PrefixExp = Inh_PrefixExp {comments_Inh_PrefixExp :: ([MToken]),indent_Inh_PrefixExp :: Int,parentOperatorAssociative_Inh_PrefixExp :: Bool,parentOperatorPrecedence_Inh_PrefixExp :: OperatorLevel,ppconf_Inh_PrefixExp :: PrettyPrintConfig}+data Syn_PrefixExp = Syn_PrefixExp {comments_Syn_PrefixExp :: ([MToken]),copy_Syn_PrefixExp :: PrefixExp,isAssociative_Syn_PrefixExp :: Bool,isLiteral_Syn_PrefixExp :: Bool,isMultiline_Syn_PrefixExp :: Bool,potentiallyAmbiguousAsStatement_Syn_PrefixExp :: Bool,precedence_Syn_PrefixExp :: OperatorLevel,pretty_Syn_PrefixExp :: Doc}+wrap_PrefixExp :: T_PrefixExp ->+                  Inh_PrefixExp ->+                  Syn_PrefixExp+wrap_PrefixExp sem (Inh_PrefixExp _lhsIcomments _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOprecedence,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf+     in  (Syn_PrefixExp _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOpotentiallyAmbiguousAsStatement _lhsOprecedence _lhsOpretty))+sem_PrefixExp_PFVar :: MToken ->+                       T_ExprSuffixList ->+                       T_PrefixExp+sem_PrefixExp_PFVar name_ suffixes_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisLiteral :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOprecedence :: OperatorLevel+              _lhsOcopy :: PrefixExp+              _lhsOcomments :: ([MToken])+              _suffixesOcomments :: ([MToken])+              _suffixesOindent :: Int+              _suffixesOppconf :: PrettyPrintConfig+              _suffixesIcomments :: ([MToken])+              _suffixesIcopy :: ExprSuffixList+              _suffixesIisAssociative :: Bool+              _suffixesIisMultiline :: Bool+              _suffixesIprecedence :: OperatorLevel+              _suffixesIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 570 "src/GLua/AG/PrettyPrint.ag" #-}+                   tok name_ <> _suffixesIpretty+                   {-# LINE 5786 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 571 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5791 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _suffixesIisAssociative+                   {-# LINE 5796 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _suffixesIisMultiline+                   {-# LINE 5801 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5806 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 250 "src/GLua/AG/PrettyPrint.ag" #-}+                   _suffixesIprecedence+                   {-# LINE 5811 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   PFVar name_ _suffixesIcopy+                   {-# LINE 5816 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5821 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _suffixesIcomments+                   {-# LINE 5826 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _suffixesOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 5831 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _suffixesOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5836 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _suffixesOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5841 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _suffixesIcomments,_suffixesIcopy,_suffixesIisAssociative,_suffixesIisMultiline,_suffixesIprecedence,_suffixesIpretty) =+                  suffixes_ _suffixesOcomments _suffixesOindent _suffixesOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOprecedence,_lhsOpretty)))+sem_PrefixExp_ExprVar :: T_MExpr ->+                         T_ExprSuffixList ->+                         T_PrefixExp+sem_PrefixExp_ExprVar expr_ suffixes_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIparentOperatorAssociative+       _lhsIparentOperatorPrecedence+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOprecedence :: OperatorLevel+              _lhsOisLiteral :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOisAssociative :: Bool+              _lhsOisMultiline :: Bool+              _lhsOcopy :: PrefixExp+              _lhsOcomments :: ([MToken])+              _exprOcomments :: ([MToken])+              _exprOindent :: Int+              _exprOparentOperatorAssociative :: Bool+              _exprOparentOperatorPrecedence :: OperatorLevel+              _exprOppconf :: PrettyPrintConfig+              _suffixesOcomments :: ([MToken])+              _suffixesOindent :: Int+              _suffixesOppconf :: PrettyPrintConfig+              _exprIcomments :: ([MToken])+              _exprIcopy :: MExpr+              _exprIisAssociative :: Bool+              _exprIisLiteral :: Bool+              _exprIisMultiline :: Bool+              _exprIpos :: Region+              _exprIprecedence :: OperatorLevel+              _exprIpretty :: Doc+              _exprIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _suffixesIcomments :: ([MToken])+              _suffixesIcopy :: ExprSuffixList+              _suffixesIisAssociative :: Bool+              _suffixesIisMultiline :: Bool+              _suffixesIprecedence :: OperatorLevel+              _suffixesIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 572 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if _noparens     then _exprIpretty else parens _lhsIppconf NonEmpty _exprIpretty) <> _suffixesIpretty+                   {-# LINE 5889 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOprecedence =+                  ({-# LINE 573 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _noparens     then _exprIprecedence else OperatorLevel8+                   {-# LINE 5894 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLiteral =+                  ({-# LINE 574 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 5899 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _containsParenthesizedExpr =+                  ({-# LINE 578 "src/GLua/AG/PrettyPrint.ag" #-}+                   case _exprIcopy of+                      MExpr _ (APrefixExpr _) -> True+                      _ -> False+                   {-# LINE 5906 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _noparens =+                  ({-# LINE 581 "src/GLua/AG/PrettyPrint.ag" #-}+                   (removeRedundantParens _lhsIppconf || minimizeParens _lhsIppconf) && (_containsParenthesizedExpr     || (_lhsIparentOperatorPrecedence == TopLevelExpression || _exprIisLiteral) && length _suffixesIcopy == 0) ||+                   (minimizeParens _lhsIppconf && length _suffixesIcopy == 0 &&+                       ( _lhsIparentOperatorPrecedence < _exprIprecedence+                       || assumeOperatorAssociativity _lhsIppconf+                       && _lhsIparentOperatorPrecedence == _exprIprecedence+                       && _lhsIparentOperatorAssociative+                       )+                   )+                   {-# LINE 5918 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 605 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 5923 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisAssociative =+                  ({-# LINE 252 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIisAssociative && _suffixesIisAssociative+                   {-# LINE 5928 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIisMultiline || _suffixesIisMultiline+                   {-# LINE 5933 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ExprVar _exprIcopy _suffixesIcopy+                   {-# LINE 5938 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 5943 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _suffixesIcomments+                   {-# LINE 5948 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 5953 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5958 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOparentOperatorAssociative =+                  ({-# LINE 243 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIparentOperatorAssociative+                   {-# LINE 5963 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOparentOperatorPrecedence =+                  ({-# LINE 242 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIparentOperatorPrecedence+                   {-# LINE 5968 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5973 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _suffixesOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprIcomments+                   {-# LINE 5978 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _suffixesOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 5983 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _suffixesOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 5988 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _exprIcomments,_exprIcopy,_exprIisAssociative,_exprIisLiteral,_exprIisMultiline,_exprIpos,_exprIprecedence,_exprIpretty,_exprIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  expr_ _exprOcomments _exprOindent _exprOparentOperatorAssociative _exprOparentOperatorPrecedence _exprOppconf+              ( _suffixesIcomments,_suffixesIcopy,_suffixesIisAssociative,_suffixesIisMultiline,_suffixesIprecedence,_suffixesIpretty) =+                  suffixes_ _suffixesOcomments _suffixesOindent _suffixesOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisAssociative,_lhsOisLiteral,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOprecedence,_lhsOpretty)))+-- Stat --------------------------------------------------------+-- cata+sem_Stat :: Stat ->+            T_Stat+sem_Stat (Def _vars) =+    (sem_Stat_Def (sem_VarsList _vars))+sem_Stat (LocDef _vars) =+    (sem_Stat_LocDef (sem_VarsList _vars))+sem_Stat (AFuncCall _fn) =+    (sem_Stat_AFuncCall (sem_PrefixExp _fn))+sem_Stat (ALabel _lbl) =+    (sem_Stat_ALabel _lbl)+sem_Stat (ABreak) =+    (sem_Stat_ABreak)+sem_Stat (AContinue) =+    (sem_Stat_AContinue)+sem_Stat (AGoto _lbl) =+    (sem_Stat_AGoto _lbl)+sem_Stat (ADo _body) =+    (sem_Stat_ADo (sem_Block _body))+sem_Stat (AWhile _cond _body) =+    (sem_Stat_AWhile (sem_MExpr _cond) (sem_Block _body))+sem_Stat (ARepeat _body _cond) =+    (sem_Stat_ARepeat (sem_Block _body) (sem_MExpr _cond))+sem_Stat (AIf _cond _body _elifs _els) =+    (sem_Stat_AIf (sem_MExpr _cond) (sem_Block _body) (sem_ElseIfList _elifs) (sem_Else _els))+sem_Stat (ANFor _var _val _to _step _body) =+    (sem_Stat_ANFor _var (sem_MExpr _val) (sem_MExpr _to) (sem_MExpr _step) (sem_Block _body))+sem_Stat (AGFor _vars _vals _body) =+    (sem_Stat_AGFor _vars (sem_MExprList _vals) (sem_Block _body))+sem_Stat (AFunc _name _args _body) =+    (sem_Stat_AFunc (sem_FuncName _name) _args (sem_Block _body))+sem_Stat (ALocFunc _name _args _body) =+    (sem_Stat_ALocFunc (sem_FuncName _name) _args (sem_Block _body))+-- semantic domain+type T_Stat = ([MToken]) ->+              Int ->+              Bool ->+              Bool ->+              PrettyPrintConfig ->+              Region ->+              ( ([MToken]),Stat,Bool,Bool,Bool,Doc)+data Inh_Stat = Inh_Stat {comments_Inh_Stat :: ([MToken]),indent_Inh_Stat :: Int,isLastStatement_Inh_Stat :: Bool,potentiallyAmbiguousAsStatement_Inh_Stat :: Bool,ppconf_Inh_Stat :: PrettyPrintConfig,statRegion_Inh_Stat :: Region}+data Syn_Stat = Syn_Stat {comments_Syn_Stat :: ([MToken]),copy_Syn_Stat :: Stat,hasBreaking_Syn_Stat :: Bool,isMultiline_Syn_Stat :: Bool,potentiallyAmbiguousAsStatement_Syn_Stat :: Bool,pretty_Syn_Stat :: Doc}+wrap_Stat :: T_Stat ->+             Inh_Stat ->+             Syn_Stat+wrap_Stat sem (Inh_Stat _lhsIcomments _lhsIindent _lhsIisLastStatement _lhsIpotentiallyAmbiguousAsStatement _lhsIppconf _lhsIstatRegion) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIisLastStatement _lhsIpotentiallyAmbiguousAsStatement _lhsIppconf _lhsIstatRegion+     in  (Syn_Stat _lhsOcomments _lhsOcopy _lhsOhasBreaking _lhsOisMultiline _lhsOpotentiallyAmbiguousAsStatement _lhsOpretty))+sem_Stat_Def :: T_VarsList ->+                T_Stat+sem_Stat_Def vars_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _varsOisHead :: Bool+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _varsOcomments :: ([MToken])+              _varsOindent :: Int+              _varsOppconf :: PrettyPrintConfig+              _varsIcomments :: ([MToken])+              _varsIcopy :: VarsList+              _varsIexprPretty :: Doc+              _varsIisDefined :: Bool+              _varsIisLastDefinedVar :: Bool+              _varsIisMultiline :: Bool+              _varsIpretty :: Doc+              _varsIvarPretty :: Doc+              _varsIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpretty =+                  ({-# LINE 471 "src/GLua/AG/PrettyPrint.ag" #-}+                   _varsIpretty <> _semicolon+                   {-# LINE 6076 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _semicolon =+                  ({-# LINE 472 "src/GLua/AG/PrettyPrint.ag" #-}+                   if semicolons _lhsIppconf || _wouldBeAmbiguous     then zchr ';' else empty+                   {-# LINE 6081 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _wouldBeAmbiguous =+                  ({-# LINE 473 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIpotentiallyAmbiguousAsStatement && _varsIwouldBeAmbiguousIfNextStatementIsExprVar+                   {-# LINE 6086 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varsOisHead =+                  ({-# LINE 474 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6091 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6096 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _varsIisMultiline+                   {-# LINE 6101 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6106 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   Def _varsIcopy+                   {-# LINE 6111 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6116 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _varsIcomments+                   {-# LINE 6121 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6126 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 6131 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 6136 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _varsIcomments,_varsIcopy,_varsIexprPretty,_varsIisDefined,_varsIisLastDefinedVar,_varsIisMultiline,_varsIpretty,_varsIvarPretty,_varsIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  vars_ _varsOcomments _varsOindent _varsOisHead _varsOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_LocDef :: T_VarsList ->+                   T_Stat+sem_Stat_LocDef vars_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _varsOisHead :: Bool+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _varsOcomments :: ([MToken])+              _varsOindent :: Int+              _varsOppconf :: PrettyPrintConfig+              _varsIcomments :: ([MToken])+              _varsIcopy :: VarsList+              _varsIexprPretty :: Doc+              _varsIisDefined :: Bool+              _varsIisLastDefinedVar :: Bool+              _varsIisMultiline :: Bool+              _varsIpretty :: Doc+              _varsIvarPretty :: Doc+              _varsIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpretty =+                  ({-# LINE 475 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "local" <-> _varsIpretty <> _semicolon+                   {-# LINE 6172 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _semicolon =+                  ({-# LINE 476 "src/GLua/AG/PrettyPrint.ag" #-}+                   if semicolons _lhsIppconf || _wouldBeAmbiguous     then zchr ';' else empty+                   {-# LINE 6177 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _wouldBeAmbiguous =+                  ({-# LINE 477 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIpotentiallyAmbiguousAsStatement && _varsIwouldBeAmbiguousIfNextStatementIsExprVar+                   {-# LINE 6182 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varsOisHead =+                  ({-# LINE 478 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6187 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6192 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _varsIisMultiline+                   {-# LINE 6197 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6202 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   LocDef _varsIcopy+                   {-# LINE 6207 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6212 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _varsIcomments+                   {-# LINE 6217 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6222 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 6227 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 6232 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _varsIcomments,_varsIcopy,_varsIexprPretty,_varsIisDefined,_varsIisLastDefinedVar,_varsIisMultiline,_varsIpretty,_varsIvarPretty,_varsIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  vars_ _varsOcomments _varsOindent _varsOisHead _varsOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_AFuncCall :: T_PrefixExp ->+                      T_Stat+sem_Stat_AFuncCall fn_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _fnOparentOperatorPrecedence :: OperatorLevel+              _fnOparentOperatorAssociative :: Bool+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _fnOcomments :: ([MToken])+              _fnOindent :: Int+              _fnOppconf :: PrettyPrintConfig+              _fnIcomments :: ([MToken])+              _fnIcopy :: PrefixExp+              _fnIisAssociative :: Bool+              _fnIisLiteral :: Bool+              _fnIisMultiline :: Bool+              _fnIpotentiallyAmbiguousAsStatement :: Bool+              _fnIprecedence :: OperatorLevel+              _fnIpretty :: Doc+              _lhsOpretty =+                  ({-# LINE 479 "src/GLua/AG/PrettyPrint.ag" #-}+                   _fnIpretty <> _semicolon+                   {-# LINE 6268 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _semicolon =+                  ({-# LINE 480 "src/GLua/AG/PrettyPrint.ag" #-}+                   if semicolons _lhsIppconf || _lhsIpotentiallyAmbiguousAsStatement then zchr ';' else empty+                   {-# LINE 6273 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _fnOparentOperatorPrecedence =+                  ({-# LINE 481 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 6278 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _fnOparentOperatorAssociative =+                  ({-# LINE 482 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6283 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6288 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _fnIisMultiline+                   {-# LINE 6293 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   _fnIpotentiallyAmbiguousAsStatement+                   {-# LINE 6298 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AFuncCall _fnIcopy+                   {-# LINE 6303 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6308 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _fnIcomments+                   {-# LINE 6313 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _fnOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6318 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _fnOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 6323 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _fnOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 6328 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _fnIcomments,_fnIcopy,_fnIisAssociative,_fnIisLiteral,_fnIisMultiline,_fnIpotentiallyAmbiguousAsStatement,_fnIprecedence,_fnIpretty) =+                  fn_ _fnOcomments _fnOindent _fnOparentOperatorAssociative _fnOparentOperatorPrecedence _fnOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_ALabel :: MToken ->+                   T_Stat+sem_Stat_ALabel lbl_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 483 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "::" <> _whitespace     <> tok lbl_ <> _whitespace     <> zeroWidthText "::"+                   {-# LINE 6351 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _whitespace =+                  ({-# LINE 484 "src/GLua/AG/PrettyPrint.ag" #-}+                   if spaceAfterLabel _lhsIppconf then zeroWidthText " " else empty+                   {-# LINE 6356 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6361 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6366 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6371 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ALabel lbl_+                   {-# LINE 6376 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6381 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6386 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_ABreak :: T_Stat+sem_Stat_ABreak =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 485 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "break" <> _semicolon+                   {-# LINE 6406 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _semicolon =+                  ({-# LINE 486 "src/GLua/AG/PrettyPrint.ag" #-}+                   if semicolons _lhsIppconf then zchr ';' else empty+                   {-# LINE 6411 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 487 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6416 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6421 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6426 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ABreak+                   {-# LINE 6431 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6436 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6441 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_AContinue :: T_Stat+sem_Stat_AContinue =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 488 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "continue" <> _semicolon+                   {-# LINE 6461 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _semicolon =+                  ({-# LINE 489 "src/GLua/AG/PrettyPrint.ag" #-}+                   if semicolons _lhsIppconf then zchr ';' else empty+                   {-# LINE 6466 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 490 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6471 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6476 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6481 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AContinue+                   {-# LINE 6486 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6491 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6496 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_AGoto :: MToken ->+                  T_Stat+sem_Stat_AGoto lbl_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 491 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "goto" <-> tok lbl_ <> _semicolon+                   {-# LINE 6517 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _semicolon =+                  ({-# LINE 492 "src/GLua/AG/PrettyPrint.ag" #-}+                   if semicolons _lhsIppconf then zchr ';' else empty+                   {-# LINE 6522 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 290 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6527 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6532 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6537 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AGoto lbl_+                   {-# LINE 6542 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6547 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6552 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_ADo :: T_Block ->+                T_Stat+sem_Stat_ADo body_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOisMultiline :: Bool+              _lhsOpretty :: Doc+              _bodyOindent :: Int+              _lhsOhasBreaking :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _lhsOisMultiline =+                  ({-# LINE 494 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6583 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 495 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "do" $+$ _bodyIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")+                   {-# LINE 6588 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 496 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 6593 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 497 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6598 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6603 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ADo _bodyIcopy+                   {-# LINE 6608 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6613 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 6618 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6623 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 6628 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 6633 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_AWhile :: T_MExpr ->+                   T_Block ->+                   T_Stat+sem_Stat_AWhile cond_ body_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOisMultiline :: Bool+              _condOparentOperatorPrecedence :: OperatorLevel+              _condOparentOperatorAssociative :: Bool+              _lhsOpretty :: Doc+              _bodyOindent :: Int+              _lhsOhasBreaking :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _condOcomments :: ([MToken])+              _condOindent :: Int+              _condOppconf :: PrettyPrintConfig+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _condIcomments :: ([MToken])+              _condIcopy :: MExpr+              _condIisAssociative :: Bool+              _condIisLiteral :: Bool+              _condIisMultiline :: Bool+              _condIpos :: Region+              _condIprecedence :: OperatorLevel+              _condIpretty :: Doc+              _condIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _lhsOisMultiline =+                  ({-# LINE 498 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6681 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOparentOperatorPrecedence =+                  ({-# LINE 499 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 6686 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOparentOperatorAssociative =+                  ({-# LINE 500 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6691 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 501 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "while" <-> _condIpretty <-> zeroWidthText "do" $+$ _bodyIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")+                   {-# LINE 6696 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 502 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 6701 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 503 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6706 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6711 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AWhile _condIcopy _bodyIcopy+                   {-# LINE 6716 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6721 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 6726 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6731 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 6736 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 6741 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _condIcomments+                   {-# LINE 6746 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 6751 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 6756 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _condIcomments,_condIcopy,_condIisAssociative,_condIisLiteral,_condIisMultiline,_condIpos,_condIprecedence,_condIpretty,_condIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  cond_ _condOcomments _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_ARepeat :: T_Block ->+                    T_MExpr ->+                    T_Stat+sem_Stat_ARepeat body_ cond_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOpretty :: Doc+              _bodyOindent :: Int+              _condOparentOperatorPrecedence :: OperatorLevel+              _condOparentOperatorAssociative :: Bool+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _condOcomments :: ([MToken])+              _condOindent :: Int+              _condOppconf :: PrettyPrintConfig+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _condIcomments :: ([MToken])+              _condIcopy :: MExpr+              _condIisAssociative :: Bool+              _condIisLiteral :: Bool+              _condIisMultiline :: Bool+              _condIpos :: Region+              _condIprecedence :: OperatorLevel+              _condIpretty :: Doc+              _condIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpretty =+                  ({-# LINE 504 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "repeat" $+$ _bodyIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "until" <-> _condIpretty)+                   {-# LINE 6806 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 505 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 6811 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOparentOperatorPrecedence =+                  ({-# LINE 506 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 6816 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOparentOperatorAssociative =+                  ({-# LINE 507 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6821 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 508 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6826 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIisMultiline || _condIisMultiline+                   {-# LINE 6831 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6836 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ARepeat _bodyIcopy _condIcopy+                   {-# LINE 6841 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 6846 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _condIcomments+                   {-# LINE 6851 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 6856 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 6861 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 6866 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 6871 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 6876 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 6881 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+              ( _condIcomments,_condIcopy,_condIisAssociative,_condIisLiteral,_condIisMultiline,_condIpos,_condIprecedence,_condIpretty,_condIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  cond_ _condOcomments _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_AIf :: T_MExpr ->+                T_Block ->+                T_ElseIfList ->+                T_Else ->+                T_Stat+sem_Stat_AIf cond_ body_ elifs_ els_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _condOparentOperatorPrecedence :: OperatorLevel+              _condOparentOperatorAssociative :: Bool+              _bodyOindent :: Int+              _bodyOstatRegion :: Region+              _lhsOpretty :: Doc+              _lhsOhasBreaking :: Bool+              _lhsOisMultiline :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _condOcomments :: ([MToken])+              _condOindent :: Int+              _condOppconf :: PrettyPrintConfig+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _elifsOcomments :: ([MToken])+              _elifsOindent :: Int+              _elifsOppconf :: PrettyPrintConfig+              _elsOcomments :: ([MToken])+              _elsOindent :: Int+              _elsOppconf :: PrettyPrintConfig+              _elsOstatRegion :: Region+              _condIcomments :: ([MToken])+              _condIcopy :: MExpr+              _condIisAssociative :: Bool+              _condIisLiteral :: Bool+              _condIisMultiline :: Bool+              _condIpos :: Region+              _condIprecedence :: OperatorLevel+              _condIpretty :: Doc+              _condIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _elifsIcomments :: ([MToken])+              _elifsIcopy :: ElseIfList+              _elifsIelsesExist :: Bool+              _elifsIisMultiline :: Bool+              _elifsIpos :: Region+              _elifsIpretty :: Doc+              _elsIcomments :: ([MToken])+              _elsIcopy :: Else+              _elsIelsesExist :: Bool+              _elsIisMultiline :: Bool+              _elsIpos :: Region+              _elsIpretty :: Doc+              _isMultiline =+                  ({-# LINE 509 "src/GLua/AG/PrettyPrint.ag" #-}+                   _condIisMultiline || _bodyIisMultiline || _bodyIstatementCount > 1 || _bodyIstatementCount == 1 && not _bodyIhasBreaking || _elifsIelsesExist || _elsIelsesExist+                   {-# LINE 6952 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _singleLinePretty =+                  ({-# LINE 510 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "if" <-> _condIpretty <-> zeroWidthText "then" <-> _bodyIpretty <-> zeroWidthText "end"+                   {-# LINE 6957 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _multilinePretty =+                  ({-# LINE 511 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "if" <-> _condIpretty <-> zeroWidthText "then" $+$ _bodyIpretty $+$ _elifsIpretty $+$ _elsIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")+                   {-# LINE 6962 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOparentOperatorPrecedence =+                  ({-# LINE 512 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 6967 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOparentOperatorAssociative =+                  ({-# LINE 513 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 6972 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 514 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _isMultiline     then _lhsIindent + 1 else 0+                   {-# LINE 6977 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 515 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion `upto` _elifsIpos `upto` _elsIpos+                   {-# LINE 6982 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 516 "src/GLua/AG/PrettyPrint.ag" #-}+                   if _isMultiline     then _multilinePretty     else _singleLinePretty+                   {-# LINE 6987 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 517 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 6992 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _isMultiline+                   {-# LINE 6997 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7002 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AIf _condIcopy _bodyIcopy _elifsIcopy _elsIcopy+                   {-# LINE 7007 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7012 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _elsIcomments+                   {-# LINE 7017 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7022 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7027 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _condOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7032 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _condIcomments+                   {-# LINE 7037 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7042 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elifsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 7047 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elifsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7052 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elifsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7057 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _elifsIcomments+                   {-# LINE 7062 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7067 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7072 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _elsOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 7077 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _condIcomments,_condIcopy,_condIisAssociative,_condIisLiteral,_condIisMultiline,_condIpos,_condIprecedence,_condIpretty,_condIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  cond_ _condOcomments _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+              ( _elifsIcomments,_elifsIcopy,_elifsIelsesExist,_elifsIisMultiline,_elifsIpos,_elifsIpretty) =+                  elifs_ _elifsOcomments _elifsOindent _elifsOppconf+              ( _elsIcomments,_elsIcopy,_elsIelsesExist,_elsIisMultiline,_elsIpos,_elsIpretty) =+                  els_ _elsOcomments _elsOindent _elsOppconf _elsOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_ANFor :: MToken ->+                  T_MExpr ->+                  T_MExpr ->+                  T_MExpr ->+                  T_Block ->+                  T_Stat+sem_Stat_ANFor var_ val_ to_ step_ body_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOisMultiline :: Bool+              _lhsOpretty :: Doc+              _valOparentOperatorPrecedence :: OperatorLevel+              _valOparentOperatorAssociative :: Bool+              _toOparentOperatorPrecedence :: OperatorLevel+              _toOparentOperatorAssociative :: Bool+              _stepOparentOperatorPrecedence :: OperatorLevel+              _stepOparentOperatorAssociative :: Bool+              _bodyOindent :: Int+              _lhsOhasBreaking :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _valOcomments :: ([MToken])+              _valOindent :: Int+              _valOppconf :: PrettyPrintConfig+              _toOcomments :: ([MToken])+              _toOindent :: Int+              _toOppconf :: PrettyPrintConfig+              _stepOcomments :: ([MToken])+              _stepOindent :: Int+              _stepOppconf :: PrettyPrintConfig+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _valIcomments :: ([MToken])+              _valIcopy :: MExpr+              _valIisAssociative :: Bool+              _valIisLiteral :: Bool+              _valIisMultiline :: Bool+              _valIpos :: Region+              _valIprecedence :: OperatorLevel+              _valIpretty :: Doc+              _valIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _toIcomments :: ([MToken])+              _toIcopy :: MExpr+              _toIisAssociative :: Bool+              _toIisLiteral :: Bool+              _toIisMultiline :: Bool+              _toIpos :: Region+              _toIprecedence :: OperatorLevel+              _toIpretty :: Doc+              _toIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _stepIcomments :: ([MToken])+              _stepIcopy :: MExpr+              _stepIisAssociative :: Bool+              _stepIisLiteral :: Bool+              _stepIisMultiline :: Bool+              _stepIpos :: Region+              _stepIprecedence :: OperatorLevel+              _stepIpretty :: Doc+              _stepIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _lhsOisMultiline =+                  ({-# LINE 518 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7162 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _step =+                  ({-# LINE 519 "src/GLua/AG/PrettyPrint.ag" #-}+                   case _stepIcopy of+                       MExpr _ (ANumber "1") -> empty+                       _ -> _comma     <> _stepIpretty+                   {-# LINE 7169 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 522 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "for" <-> tok var_ <-> zchr '=' <-> _valIpretty <> _comma     <> _toIpretty <> _step     <-> zeroWidthText "do" $+$ _bodyIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")+                   {-# LINE 7174 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _comma =+                  ({-# LINE 523 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ',' <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)+                   {-# LINE 7179 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valOparentOperatorPrecedence =+                  ({-# LINE 524 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 7184 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valOparentOperatorAssociative =+                  ({-# LINE 525 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7189 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _toOparentOperatorPrecedence =+                  ({-# LINE 526 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 7194 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _toOparentOperatorAssociative =+                  ({-# LINE 527 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7199 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _stepOparentOperatorPrecedence =+                  ({-# LINE 528 "src/GLua/AG/PrettyPrint.ag" #-}+                   TopLevelExpression+                   {-# LINE 7204 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _stepOparentOperatorAssociative =+                  ({-# LINE 529 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7209 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 530 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 7214 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 531 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7219 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7224 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ANFor var_ _valIcopy _toIcopy _stepIcopy _bodyIcopy+                   {-# LINE 7229 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7234 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 7239 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7244 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7249 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7254 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _toOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valIcomments+                   {-# LINE 7259 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _toOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7264 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _toOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7269 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _stepOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _toIcomments+                   {-# LINE 7274 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _stepOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7279 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _stepOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7284 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _stepIcomments+                   {-# LINE 7289 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7294 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 7299 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _valIcomments,_valIcopy,_valIisAssociative,_valIisLiteral,_valIisMultiline,_valIpos,_valIprecedence,_valIpretty,_valIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  val_ _valOcomments _valOindent _valOparentOperatorAssociative _valOparentOperatorPrecedence _valOppconf+              ( _toIcomments,_toIcopy,_toIisAssociative,_toIisLiteral,_toIisMultiline,_toIpos,_toIprecedence,_toIpretty,_toIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  to_ _toOcomments _toOindent _toOparentOperatorAssociative _toOparentOperatorPrecedence _toOppconf+              ( _stepIcomments,_stepIcopy,_stepIisAssociative,_stepIisLiteral,_stepIisMultiline,_stepIpos,_stepIprecedence,_stepIpretty,_stepIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  step_ _stepOcomments _stepOindent _stepOparentOperatorAssociative _stepOparentOperatorPrecedence _stepOppconf+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_AGFor :: ([MToken]) ->+                  T_MExprList ->+                  T_Block ->+                  T_Stat+sem_Stat_AGFor vars_ vals_ body_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOisMultiline :: Bool+              _lhsOpretty :: Doc+              _bodyOindent :: Int+              _valsOisHead :: Bool+              _lhsOhasBreaking :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _valsOcomments :: ([MToken])+              _valsOindent :: Int+              _valsOppconf :: PrettyPrintConfig+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _valsIcomments :: ([MToken])+              _valsIcopy :: MExprList+              _valsIisAssociative :: Bool+              _valsIisMultiline :: Bool+              _valsIpos :: Region+              _valsIprecedence :: OperatorLevel+              _valsIpretty :: Doc+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _lhsOisMultiline =+                  ({-# LINE 532 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7351 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 533 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "for" <-> printList tok (render _comma    ) vars_ <-> zeroWidthText "in" <-> _valsIpretty <-> zeroWidthText "do" $+$ _bodyIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")+                   {-# LINE 7356 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 534 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 7361 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _comma =+                  ({-# LINE 535 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ',' <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)+                   {-# LINE 7366 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valsOisHead =+                  ({-# LINE 536 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7371 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 537 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7376 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7381 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AGFor vars_ _valsIcopy _bodyIcopy+                   {-# LINE 7386 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7391 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 7396 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7401 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valsOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7406 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _valsOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7411 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _valsIcomments+                   {-# LINE 7416 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7421 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 7426 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _valsIcomments,_valsIcopy,_valsIisAssociative,_valsIisMultiline,_valsIpos,_valsIprecedence,_valsIpretty) =+                  vals_ _valsOcomments _valsOindent _valsOisHead _valsOppconf+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_AFunc :: T_FuncName ->+                  ([MToken]) ->+                  T_Block ->+                  T_Stat+sem_Stat_AFunc name_ args_ body_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOisMultiline :: Bool+              _lhsOpretty :: Doc+              _bodyOindent :: Int+              _lhsOhasBreaking :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _nameOcomments :: ([MToken])+              _nameOindent :: Int+              _nameOppconf :: PrettyPrintConfig+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _nameIcomments :: ([MToken])+              _nameIcopy :: FuncName+              _nameIisMultiline :: Bool+              _nameIpretty :: Doc+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _lhsOisMultiline =+                  ({-# LINE 538 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7470 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 539 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "function" <-> _nameIpretty <> parens _lhsIppconf _emptyParams     (printList tok (render _comma    ) args_) $+$ _bodyIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")+                   {-# LINE 7475 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _emptyParams =+                  ({-# LINE 540 "src/GLua/AG/PrettyPrint.ag" #-}+                   toEmpty $ null args_+                   {-# LINE 7480 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _comma =+                  ({-# LINE 541 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ',' <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)+                   {-# LINE 7485 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 542 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 7490 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 543 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7495 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7500 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AFunc _nameIcopy args_ _bodyIcopy+                   {-# LINE 7505 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7510 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 7515 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _nameOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7520 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _nameOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7525 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _nameOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7530 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _nameIcomments+                   {-# LINE 7535 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7540 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 7545 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _nameIcomments,_nameIcopy,_nameIisMultiline,_nameIpretty) =+                  name_ _nameOcomments _nameOindent _nameOppconf+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+sem_Stat_ALocFunc :: T_FuncName ->+                     ([MToken]) ->+                     T_Block ->+                     T_Stat+sem_Stat_ALocFunc name_ args_ body_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisLastStatement+       _lhsIpotentiallyAmbiguousAsStatement+       _lhsIppconf+       _lhsIstatRegion ->+         (let _lhsOisMultiline :: Bool+              _lhsOpretty :: Doc+              _bodyOindent :: Int+              _lhsOhasBreaking :: Bool+              _lhsOpotentiallyAmbiguousAsStatement :: Bool+              _lhsOcopy :: Stat+              _lhsOcomments :: ([MToken])+              _nameOcomments :: ([MToken])+              _nameOindent :: Int+              _nameOppconf :: PrettyPrintConfig+              _bodyOcomments :: ([MToken])+              _bodyOppconf :: PrettyPrintConfig+              _bodyOstatRegion :: Region+              _nameIcomments :: ([MToken])+              _nameIcopy :: FuncName+              _nameIisMultiline :: Bool+              _nameIpretty :: Doc+              _bodyIcomments :: ([MToken])+              _bodyIcopy :: Block+              _bodyIhasBreaking :: Bool+              _bodyIisMultiline :: Bool+              _bodyIpretty :: Doc+              _bodyIstatementCount :: Int+              _lhsOisMultiline =+                  ({-# LINE 544 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7589 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpretty =+                  ({-# LINE 545 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "local function" <-> _nameIpretty <> parens _lhsIppconf _emptyParams     (printList tok (render _comma    ) args_) $+$ _bodyIpretty $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")+                   {-# LINE 7594 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _emptyParams =+                  ({-# LINE 546 "src/GLua/AG/PrettyPrint.ag" #-}+                   toEmpty $ null args_+                   {-# LINE 7599 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _comma =+                  ({-# LINE 547 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ',' <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)+                   {-# LINE 7604 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOindent =+                  ({-# LINE 548 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent + 1+                   {-# LINE 7609 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOhasBreaking =+                  ({-# LINE 549 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7614 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOpotentiallyAmbiguousAsStatement =+                  ({-# LINE 301 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7619 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ALocFunc _nameIcopy args_ _bodyIcopy+                   {-# LINE 7624 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7629 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _bodyIcomments+                   {-# LINE 7634 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _nameOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7639 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _nameOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7644 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _nameOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7649 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _nameIcomments+                   {-# LINE 7654 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7659 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _bodyOstatRegion =+                  ({-# LINE 296 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIstatRegion+                   {-# LINE 7664 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _nameIcomments,_nameIcopy,_nameIisMultiline,_nameIpretty) =+                  name_ _nameOcomments _nameOindent _nameOppconf+              ( _bodyIcomments,_bodyIcopy,_bodyIhasBreaking,_bodyIisMultiline,_bodyIpretty,_bodyIstatementCount) =+                  body_ _bodyOcomments _bodyOindent _bodyOppconf _bodyOstatRegion+          in  ( _lhsOcomments,_lhsOcopy,_lhsOhasBreaking,_lhsOisMultiline,_lhsOpotentiallyAmbiguousAsStatement,_lhsOpretty)))+-- UnOp --------------------------------------------------------+-- cata+sem_UnOp :: UnOp ->+            T_UnOp+sem_UnOp (UnMinus) =+    (sem_UnOp_UnMinus)+sem_UnOp (ANot) =+    (sem_UnOp_ANot)+sem_UnOp (AHash) =+    (sem_UnOp_AHash)+-- semantic domain+type T_UnOp = ([MToken]) ->+              Int ->+              PrettyPrintConfig ->+              ( ([MToken]),UnOp,Bool,Doc)+data Inh_UnOp = Inh_UnOp {comments_Inh_UnOp :: ([MToken]),indent_Inh_UnOp :: Int,ppconf_Inh_UnOp :: PrettyPrintConfig}+data Syn_UnOp = Syn_UnOp {comments_Syn_UnOp :: ([MToken]),copy_Syn_UnOp :: UnOp,isMultiline_Syn_UnOp :: Bool,pretty_Syn_UnOp :: Doc}+wrap_UnOp :: T_UnOp ->+             Inh_UnOp ->+             Syn_UnOp+wrap_UnOp sem (Inh_UnOp _lhsIcomments _lhsIindent _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf+     in  (Syn_UnOp _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty))+sem_UnOp_UnMinus :: T_UnOp+sem_UnOp_UnMinus =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisMultiline :: Bool+              _lhsOcopy :: UnOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 750 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "-"+                   {-# LINE 7706 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7711 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   UnMinus+                   {-# LINE 7716 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7721 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7726 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+sem_UnOp_ANot :: T_UnOp+sem_UnOp_ANot =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisMultiline :: Bool+              _lhsOcopy :: UnOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 751 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText (if cStyle _lhsIppconf then "!" else "not ")+                   {-# LINE 7741 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7746 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   ANot+                   {-# LINE 7751 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7756 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7761 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+sem_UnOp_AHash :: T_UnOp+sem_UnOp_AHash =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisMultiline :: Bool+              _lhsOcopy :: UnOp+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 752 "src/GLua/AG/PrettyPrint.ag" #-}+                   zeroWidthText "#"+                   {-# LINE 7776 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7781 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   AHash+                   {-# LINE 7786 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7791 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7796 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOisMultiline,_lhsOpretty)))+-- VarsList ----------------------------------------------------+-- cata+sem_VarsList :: VarsList ->+                T_VarsList+sem_VarsList list =+    (Prelude.foldr sem_VarsList_Cons sem_VarsList_Nil (Prelude.map sem_Declaration list))+-- semantic domain+type T_VarsList = ([MToken]) ->+                  Int ->+                  Bool ->+                  PrettyPrintConfig ->+                  ( ([MToken]),VarsList,Doc,Bool,Bool,Bool,Doc,Doc,Bool)+data Inh_VarsList = Inh_VarsList {comments_Inh_VarsList :: ([MToken]),indent_Inh_VarsList :: Int,isHead_Inh_VarsList :: Bool,ppconf_Inh_VarsList :: PrettyPrintConfig}+data Syn_VarsList = Syn_VarsList {comments_Syn_VarsList :: ([MToken]),copy_Syn_VarsList :: VarsList,exprPretty_Syn_VarsList :: Doc,isDefined_Syn_VarsList :: Bool,isLastDefinedVar_Syn_VarsList :: Bool,isMultiline_Syn_VarsList :: Bool,pretty_Syn_VarsList :: Doc,varPretty_Syn_VarsList :: Doc,wouldBeAmbiguousIfNextStatementIsExprVar_Syn_VarsList :: Bool}+wrap_VarsList :: T_VarsList ->+                 Inh_VarsList ->+                 Syn_VarsList+wrap_VarsList sem (Inh_VarsList _lhsIcomments _lhsIindent _lhsIisHead _lhsIppconf) =+    (let ( _lhsOcomments,_lhsOcopy,_lhsOexprPretty,_lhsOisDefined,_lhsOisLastDefinedVar,_lhsOisMultiline,_lhsOpretty,_lhsOvarPretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar) = sem _lhsIcomments _lhsIindent _lhsIisHead _lhsIppconf+     in  (Syn_VarsList _lhsOcomments _lhsOcopy _lhsOexprPretty _lhsOisDefined _lhsOisLastDefinedVar _lhsOisMultiline _lhsOpretty _lhsOvarPretty _lhsOwouldBeAmbiguousIfNextStatementIsExprVar))+sem_VarsList_Cons :: T_Declaration ->+                     T_VarsList ->+                     T_VarsList+sem_VarsList_Cons hd_ tl_ =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisHead+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _tlOisHead :: Bool+              _lhsOisLastDefinedVar :: Bool+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOexprPretty :: Doc+              _lhsOisDefined :: Bool+              _lhsOisMultiline :: Bool+              _lhsOvarPretty :: Doc+              _lhsOcopy :: VarsList+              _lhsOcomments :: ([MToken])+              _hdOcomments :: ([MToken])+              _hdOindent :: Int+              _hdOppconf :: PrettyPrintConfig+              _tlOcomments :: ([MToken])+              _tlOindent :: Int+              _tlOppconf :: PrettyPrintConfig+              _hdIcomments :: ([MToken])+              _hdIcopy :: Declaration+              _hdIexprPretty :: Doc+              _hdIisDefined :: Bool+              _hdIisMultiline :: Bool+              _hdIpretty :: Doc+              _hdIvarPretty :: Doc+              _hdIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _tlIcomments :: ([MToken])+              _tlIcopy :: VarsList+              _tlIexprPretty :: Doc+              _tlIisDefined :: Bool+              _tlIisLastDefinedVar :: Bool+              _tlIisMultiline :: Bool+              _tlIpretty :: Doc+              _tlIvarPretty :: Doc+              _tlIwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOpretty =+                  ({-# LINE 412 "src/GLua/AG/PrettyPrint.ag" #-}+                   _varPretty     <-> if _isDefined     then zchr '=' <-> _exprPretty     else empty+                   {-# LINE 7863 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _isDefined =+                  ({-# LINE 413 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisDefined || _tlIisDefined+                   {-# LINE 7868 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _varPretty =+                  ({-# LINE 414 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if _lhsIisHead then empty else _comma    ) <> _hdIvarPretty <> _tlIvarPretty+                   {-# LINE 7873 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _exprPretty =+                  ({-# LINE 415 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if _lhsIisHead || not _hdIisDefined then empty else _comma    ) <> _hdIexprPretty <> _tlIexprPretty+                   {-# LINE 7878 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _comma =+                  ({-# LINE 416 "src/GLua/AG/PrettyPrint.ag" #-}+                   (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ',' <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)+                   {-# LINE 7883 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOisHead =+                  ({-# LINE 417 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 7888 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _isLastDefinedVar =+                  ({-# LINE 418 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIisLastDefinedVar+                   {-# LINE 7893 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLastDefinedVar =+                  ({-# LINE 419 "src/GLua/AG/PrettyPrint.ag" #-}+                   _isLastDefinedVar     && not _hdIisDefined+                   {-# LINE 7898 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 420 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIwouldBeAmbiguousIfNextStatementIsExprVar || _isLastDefinedVar     && _hdIwouldBeAmbiguousIfNextStatementIsExprVar+                   {-# LINE 7903 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOexprPretty =+                  ({-# LINE 256 "src/GLua/AG/PrettyPrint.ag" #-}+                   _exprPretty+                   {-# LINE 7908 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisDefined =+                  ({-# LINE 259 "src/GLua/AG/PrettyPrint.ag" #-}+                   _isDefined+                   {-# LINE 7913 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIisMultiline || _tlIisMultiline+                   {-# LINE 7918 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOvarPretty =+                  ({-# LINE 255 "src/GLua/AG/PrettyPrint.ag" #-}+                   _varPretty+                   {-# LINE 7923 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   (:) _hdIcopy _tlIcopy+                   {-# LINE 7928 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 7933 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _tlIcomments+                   {-# LINE 7938 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 7943 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7948 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _hdOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7953 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _hdIcomments+                   {-# LINE 7958 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOindent =+                  ({-# LINE 233 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIindent+                   {-# LINE 7963 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _tlOppconf =+                  ({-# LINE 235 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIppconf+                   {-# LINE 7968 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              ( _hdIcomments,_hdIcopy,_hdIexprPretty,_hdIisDefined,_hdIisMultiline,_hdIpretty,_hdIvarPretty,_hdIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  hd_ _hdOcomments _hdOindent _hdOppconf+              ( _tlIcomments,_tlIcopy,_tlIexprPretty,_tlIisDefined,_tlIisLastDefinedVar,_tlIisMultiline,_tlIpretty,_tlIvarPretty,_tlIwouldBeAmbiguousIfNextStatementIsExprVar) =+                  tl_ _tlOcomments _tlOindent _tlOisHead _tlOppconf+          in  ( _lhsOcomments,_lhsOcopy,_lhsOexprPretty,_lhsOisDefined,_lhsOisLastDefinedVar,_lhsOisMultiline,_lhsOpretty,_lhsOvarPretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))+sem_VarsList_Nil :: T_VarsList+sem_VarsList_Nil =+    (\ _lhsIcomments+       _lhsIindent+       _lhsIisHead+       _lhsIppconf ->+         (let _lhsOpretty :: Doc+              _lhsOisLastDefinedVar :: Bool+              _lhsOexprPretty :: Doc+              _lhsOisDefined :: Bool+              _lhsOisMultiline :: Bool+              _lhsOvarPretty :: Doc+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar :: Bool+              _lhsOcopy :: VarsList+              _lhsOcomments :: ([MToken])+              _lhsOpretty =+                  ({-# LINE 422 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 7993 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisLastDefinedVar =+                  ({-# LINE 423 "src/GLua/AG/PrettyPrint.ag" #-}+                   True+                   {-# LINE 7998 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOexprPretty =+                  ({-# LINE 256 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 8003 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisDefined =+                  ({-# LINE 259 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 8008 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOisMultiline =+                  ({-# LINE 234 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 8013 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOvarPretty =+                  ({-# LINE 255 "src/GLua/AG/PrettyPrint.ag" #-}+                   empty+                   {-# LINE 8018 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOwouldBeAmbiguousIfNextStatementIsExprVar =+                  ({-# LINE 307 "src/GLua/AG/PrettyPrint.ag" #-}+                   False+                   {-# LINE 8023 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _copy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   []+                   {-# LINE 8028 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcopy =+                  ({-# LINE 236 "src/GLua/AG/PrettyPrint.ag" #-}+                   _copy+                   {-# LINE 8033 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+              _lhsOcomments =+                  ({-# LINE 274 "src/GLua/AG/PrettyPrint.ag" #-}+                   _lhsIcomments+                   {-# LINE 8038 "src/GLua/AG/PrettyPrint.hs" #-}+                   )+          in  ( _lhsOcomments,_lhsOcopy,_lhsOexprPretty,_lhsOisDefined,_lhsOisLastDefinedVar,_lhsOisMultiline,_lhsOpretty,_lhsOvarPretty,_lhsOwouldBeAmbiguousIfNextStatementIsExprVar)))
+ src/GLua/AG/Token.hs view
@@ -0,0 +1,86 @@+++{-# LANGUAGE DeriveGeneric #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+-- UUAGC 0.9.53.1 (src/GLua/AG/Token.ag)+module GLua.AG.Token where++{-# LINE 9 "src/GLua/AG/Token.ag" #-}++import Text.ParserCombinators.UU.BasicInstances hiding (pos)+import GHC.Generics+{-# LINE 13 "src/GLua/AG/Token.hs" #-}+-- MToken ------------------------------------------------------+data MToken = MToken !(Region) !(Token)+-- MTokenList --------------------------------------------------+type MTokenList = [MToken]+-- Region ------------------------------------------------------+data Region = Region !(LineColPos) !(LineColPos)+            deriving ( Generic,Show)+-- Token -------------------------------------------------------+data Token = Whitespace !(String)+           | DashComment !(String)+           | DashBlockComment !(Int) !(String)+           | SlashComment !(String)+           | SlashBlockComment !(String)+           | Semicolon+           | TNumber !(String)+           | DQString !(String)+           | SQString !(String)+           | MLString !(String)+           | TTrue+           | TFalse+           | Nil+           | VarArg+           | Plus+           | Minus+           | Multiply+           | Divide+           | Modulus+           | Power+           | TEq+           | TNEq+           | TCNEq+           | TLEQ+           | TGEQ+           | TLT+           | TGT+           | Equals+           | Concatenate+           | Colon+           | Dot+           | Comma+           | Hash+           | Not+           | CNot+           | And+           | CAnd+           | Or+           | COr+           | Function+           | Local+           | If+           | Then+           | Elseif+           | Else+           | For+           | In+           | Do+           | While+           | Until+           | Repeat+           | Continue+           | Break+           | Return+           | End+           | LRound+           | RRound+           | LCurly+           | RCurly+           | LSquare+           | RSquare+           | Label !(String)+           | Identifier !(String)+           deriving ( Eq,Generic,Ord)+-- TokenList ---------------------------------------------------+type TokenList = [Token]
+ src/GLua/ASTInstances.hs view
@@ -0,0 +1,60 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}++-- | Contains class instances and functions related to AST These are not put+-- in the AST.ag file as importing an AG file would copy the instance+-- declarations, causing duplicate instances errors.+module GLua.ASTInstances where++import GLua.AG.AST+import Data.Aeson++instance ToJSON AST where+instance FromJSON AST where++instance ToJSON Block where+instance FromJSON Block where++instance ToJSON MStat where+instance FromJSON MStat where++instance ToJSON MElse where+instance FromJSON MElse where++instance ToJSON MElseIf where+instance FromJSON MElseIf where++instance ToJSON Stat where+instance FromJSON Stat where++instance ToJSON AReturn where+instance FromJSON AReturn where++instance ToJSON FuncName where+instance FromJSON FuncName where++instance ToJSON PrefixExp where+instance FromJSON PrefixExp where++instance ToJSON PFExprSuffix where+instance FromJSON PFExprSuffix where++instance ToJSON MExpr where+instance FromJSON MExpr where++instance ToJSON Expr where+instance FromJSON Expr where++instance ToJSON Args where+instance FromJSON Args where++instance ToJSON Field where+instance FromJSON Field where++instance ToJSON FieldSep where+instance FromJSON FieldSep where++instance ToJSON BinOp where+instance FromJSON BinOp where++instance ToJSON UnOp where+instance FromJSON UnOp where
+ src/GLua/Lexer.hs view
@@ -0,0 +1,340 @@+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE NoMonomorphismRestriction #-}+{-# LANGUAGE CPP #-}++-- | Lex GLua into MTokens+module GLua.Lexer where++import GLua.AG.Token ( Region(..), MToken(..), Token(..) )++import Data.Char (ord)+import Text.ParserCombinators.UU+    ( P,+      pEnd,+      pErrors,+      (<**>),+      micro,+      pPos,+      parse,+      (<$$>),+      pMany,+      pMaybe,+      pReturn,+      pSome,+      ExtAlternative(opt, (<<|>)) )+import Text.ParserCombinators.UU.Utils ( pDigit )+import Text.ParserCombinators.UU.BasicInstances+    ( Error,+      LineColPos(..),+      Str,+      createStr,+      pMunch,+      pSatisfy,+      pSym,+      pToken,+      Insertion(Insertion) )++-- | String parser that maintains positions.+type LParser a = P (Str Char String LineColPos) a++-- | Whitespace parser that requires at least one whitespace character+parseWhitespace :: LParser String+parseWhitespace = pSome $ pSatisfy (`elem` " \r\n\t") (Insertion "Whitespace" ' ' 5)++-- | Whitespace parser that requires 0 or more whitespace characters+parseOptionalWhitespace :: LParser String+parseOptionalWhitespace = pMany $ pSatisfy (`elem` " \r\n\t") (Insertion "Whitespace" ' ' 5)++-- | Blanco parser. Parses anything. Used in parsing comments.+parseAnyChar :: LParser Char+parseAnyChar = pSatisfy (const True) (Insertion "Any character" 'y' 5)++-- See luajit's src/lj_char.c and src/lj_char.h+pIdentifierCharacter :: LParser Char+pIdentifierCharacter = pSatisfy validChar (Insertion "Identifying character (letter, number, emoji)" 'a' 5)+    where+        validChar :: Char -> Bool+        validChar c =+            between c '0' '9' ||+            between c 'A' 'Z' ||+            c == '_'          ||+            between c 'a' 'z' ||+            ord c >= 128+++pNonDigitIdentifierCharacter :: LParser Char+pNonDigitIdentifierCharacter = pSatisfy validChar (Insertion "Identifying character (letter, emoji)" 'a' 5)+    where+        validChar :: Char -> Bool+        validChar c =+            between c 'A' 'Z' ||+            c == '_'          ||+            between c 'a' 'z' ||+            ord c >= 128++between :: Char -> Char -> Char -> Bool+between c left right = c >= left && c <= right++-- | Parses a C-style block comment.+parseCBlockComment :: LParser String+parseCBlockComment = const "" <$> pToken "*/" <<|>+            (:) <$> parseAnyChar <*> parseCBlockComment++-- | Try to parse a block comment.+-- Might actually return a single line Dash comment, because for example+-- the following line is a line comment, rather than a block comment+--[===== <- missing the last '[' bracket.+parseBlockComment :: LParser Token+parseBlockComment = pToken "[" *> nested 0+    where+        -- The amount of =-signs in the string delimiter is n+        nested :: Int -> LParser Token+        nested n = pToken "=" *> nested (n + 1) <<|>+                   DashBlockComment n <$ pToken "[" <*> restString n <<|>+                   lineComment n <$> pUntilEnd++        -- Turns out we were describing a line comment all along, cheeky bastard!+        -- (the last [ of the block comment start token is missing)+        lineComment :: Int -> String -> Token+        lineComment n str = DashComment $ '[' : replicate n '=' ++ str++        -- Right-recursive grammar. This part searches for the rest of the string until it finds the ]=^n] token+        restString :: Int -> LParser String+        restString n = const "" <$> pToken ("]" ++ replicate n '=' ++ "]") <<|>+                       (:) <$> parseAnyChar <*> restString n++-- | Parse the string until the end. Used in parseLineComment among others.+pUntilEnd :: LParser String+pUntilEnd = pMunch (\c -> c /= '\n' && c /= '\r')++-- | A comment that spans until the end of the line.+parseLineComment :: String -> LParser String+parseLineComment prefix = flip const <$> pToken prefix <*> pUntilEnd++-- | Parses a multiline string except for its first character (e.g. =[ string ]=])+-- This is because the first [ could also just be parsed as a square bracket.+nestedString :: LParser String+nestedString = nested 0+    where+        -- The amount of =-signs in the string delimiter is n+        nested :: Int -> LParser String+        nested n = (\str -> "=" ++ str) <$ pToken "=" <*> nested (n + 1) <<|>+                   ('[' :) <$ pToken "[" <*> restString n++        -- Right-recursive grammar. This part searches for the rest of the string until it finds the ]=^n] token+        restString :: Int -> LParser String+        restString n = pToken ("]" ++ replicate n '=' ++ "]") <<|>+                       (:) <$> parseAnyChar <*> restString n++-- | Parse any kind of comment.+parseComment :: LParser Token+parseComment =  pToken "--" <**> -- Dash block comment and dash comment both start with "--"+                    (const <$> (parseBlockComment <<|> DashComment <$> pUntilEnd)) <<|>+                pToken "/" <**>+                    (const <$>+                        (SlashBlockComment <$ pToken "*" <*> parseCBlockComment <<|>+                        SlashComment <$> parseLineComment "/" <<|>+                        pReturn Divide -- The /-sign is here because it also starts with '/'+                        ))++-- | Parse single line strings e.g. "sdf", 'werf'.+parseLineString :: Char -> LParser String+parseLineString c = pSym c *> innerString+    where+        innerString :: LParser String+        innerString = pSym '\\' <**> -- Escaped character in string always starts with backslash+                         ((\c' str esc -> esc : c' ++ str) <$> escapeSequence <*> innerString) <<|>+                      const "" <$> pSym c <<|> -- the end of the string+                      (:) <$> pNoNewline <*> innerString -- the next character in the string++        escapeSequence :: LParser String+        escapeSequence = (:) <$> pSym 'z' <*> parseOptionalWhitespace <<|> (:[]) <$> parseAnyChar++        pNoNewline :: LParser Char+        pNoNewline = pSatisfy (/= '\n') (Insertion "Anything but a newline" c 5)+++-- | Single and multiline strings.+parseString :: LParser Token+parseString = DQString <$> parseLineString '"' <<|>+              SQString <$> parseLineString '\'' <<|>+              -- Parse either a multiline string or just a bracket.+              -- Placed here because they have the first token '[' in common+              pSym '[' <**> ((\_ -> MLString . (:) '[') <$$> nestedString <<|>+                        const <$> pReturn LSquare)++-- | Parse any kind of number.+parseNumber :: LParser Token+parseNumber = TNumber <$> ((++) <$> (pZeroPrefixedNumber <<|> pNumber) <*> (pLLULL <<|> opt parseNumberSuffix ""))+    where+        -- Numbers starting with 0 can be regular numbers, hexadecimals or binary+        pZeroPrefixedNumber :: LParser String+        pZeroPrefixedNumber =+            pSym '0' <**> (+                (\hex _0 -> _0 : hex) <$> pHexadecimal <<|>+                (\bin _0 -> _0 : bin) <$> pBinary <<|>+                (\digits _0 -> _0 : digits) <$> (pDecimal <<|> pNumber) <<|>+                pure (:[])+            )++        pNumber :: LParser String+        pNumber = (++) <$> pSome pDigit <*> opt pDecimal ""++        pDecimal :: LParser String+        pDecimal = (:) <$> pSym '.' <*> pMany pDigit++        pHexDecimal :: LParser String+        pHexDecimal = (:) <$> pSym '.' <*> pMany pHex++        pHexadecimal :: LParser String+        pHexadecimal = (:) <$> (pSym 'x' <<|> pSym 'X') <*> ((++) <$> pSome pHex <*> opt pHexDecimal "")++        pBinary :: LParser String+        pBinary = (:) <$> (pSym 'b' <<|> pSym 'B') <*> ((++) <$> pSome pBin <*> opt pDecimal "")++        pHex :: LParser Char+        pHex = pDigit <<|> pSym 'a' <<|> pSym 'b' <<|> pSym 'c' <<|> pSym 'd' <<|> pSym 'e' <<|> pSym 'f'+                      <<|> pSym 'A' <<|> pSym 'B' <<|> pSym 'C' <<|> pSym 'D' <<|> pSym 'E' <<|> pSym 'F'++        pBin :: LParser Char+        pBin = pSym '0' <<|> pSym '1'++        -- LL/ULL suffix of a number, making it signed/unsigned int64 respectively+        -- http://luajit.org/ext_ffi_api.html#literals+        pLLULL :: LParser String+        pLLULL = pULL <<|> pLL++        pLL :: LParser String+        pLL = "LL" <$ (pSym 'L' <<|> pSym 'l') <* (pSym 'L' <<|> pSym 'l')++        pULL :: LParser String+        pULL = "ULL" <$ (pSym 'U' <<|> pSym 'u') <* pLL++-- Parse the suffix of a number+parseNumberSuffix :: LParser String+parseNumberSuffix = imaginary <<|> extension+    where+        imaginary = (:[]) <$> (pSym 'i' <<|> pSym 'I')++        extension = (\e s d -> e : s ++ d) <$> (pSym 'e' <<|> pSym 'E' <<|> pSym 'p' <<|> pSym 'P')+            <*> opt (pToken "+" <<|> pToken "-") ""+            <*> pSome pDigit++-- | Parse a keyword. Note: It must really a key/word/! This parser makes sure to return an identifier when+-- it's actually an identifier that starts with that keyword.+parseKeyword :: Token -> String -> LParser Token+parseKeyword tok word = pToken word <**>+                            ((\k -> Identifier . (++) k) <$$> pSome pIdentifierCharacter <<|> const <$> pReturn tok)++-- | Parse just an identifier.+parseIdentifier :: LParser String+parseIdentifier = (:) <$> pNonDigitIdentifierCharacter <*> pMany pIdentifierCharacter++-- | Parse a label.+parseLabel :: LParser String+parseLabel = pToken "::" *> (pMaybe parseWhitespace *> parseIdentifier <* pMaybe parseWhitespace) <* pToken "::"++-- | Parse anything to do with dots. Indexaction (.), concatenation (..) or varargs (...)+parseDots :: LParser Token+parseDots = pToken "." <**> ( -- A dot means it's either a VarArg (...), concatenation (..) or just a dot (.)+                const <$> (pToken "." <**> (+                    const VarArg <$ pToken "." <<|>+                    const <$> pReturn Concatenate+                )) <<|>+                (\ds sfx dot -> TNumber $ dot ++ ds ++ sfx) <$> pSome pDigit <*> opt parseNumberSuffix "" <<|>+                const <$> pReturn Dot+                )++-- | Parse any kind of token.+parseToken :: LParser Token+parseToken =    parseComment                                 <<|>++                -- Constants+                parseString                                  <<|>+                parseNumber                                  <<|>+                parseKeyword TTrue "true"                    <<|>+                parseKeyword TFalse "false"                  <<|>+                parseKeyword Nil "nil"                       <<|>+                parseKeyword Not "not"                       <<|>+                parseKeyword And "and"                       <<|>+                parseKeyword Or "or"                         <<|>+                parseKeyword Function "function"             <<|>+                parseKeyword Local "local"                   <<|>+                parseKeyword If "if"                         <<|>+                parseKeyword Then "then"                     <<|>+                parseKeyword Elseif "elseif"                 <<|>+                parseKeyword Else "else"                     <<|>+                parseKeyword For "for"                       <<|>+                parseKeyword In "in"                         <<|>+                parseKeyword Do "do"                         <<|>+                parseKeyword While "while"                   <<|>+                parseKeyword Until "until"                   <<|>+                parseKeyword Repeat "repeat"                 <<|>+                parseKeyword Continue "continue"             <<|>+                parseKeyword Break "break"                   <<|>+                parseKeyword Return "return"                 <<|>+                parseKeyword End "end"                       <<|>++                Identifier <$> parseIdentifier               <<|>++                Semicolon <$ pToken ";"                      <<|>+                parseDots                                    <<|>++                -- Operators+                Plus <$ pToken "+"                           <<|>+                Minus <$ pToken "-"                          <<|>+                Multiply <$ pToken "*"                       <<|>+                Modulus <$ pToken "%"                        <<|>+                Power <$ pToken "^"                          <<|>+                TEq <$ pToken "=="                           <<|>+                Equals <$ pToken "="                         <<|>+                TNEq <$ pToken "~="                          <<|>+                TCNEq <$ pToken "!="                         <<|>+                CNot <$ pToken "!"                           <<|>+                TLEQ <$ pToken "<="                          <<|>+                TLT <$ pToken "<"                            <<|>+                TGEQ <$ pToken ">="                          <<|>+                TGT <$ pToken ">"                            <<|>+                Label <$> parseLabel                         <<|>+                Colon <$ pToken ":"                          <<|>+                Comma <$ pToken ","                          <<|>+                Hash <$ pToken "#"  `micro` 10               <<|> -- Add micro cost to prevent conflict with parseHashBang+                CAnd <$ pToken "&&"                          <<|>+                COr <$ pToken "||"                           <<|>++                LRound <$ pToken "("                         <<|>+                RRound <$ pToken ")"                         <<|>+                LCurly <$ pToken "{"                         <<|>+                RCurly <$ pToken "}"                         <<|>+                -- Other square bracket is parsed in parseString+                RSquare <$ pToken "]"                        <<|>+                Whitespace <$> parseWhitespace+++-- | A thing of which the region is to be parsed+annotated :: (Region -> a -> b) -> LParser a -> LParser b+annotated f p = (\s t e -> f (Region s e) t) <$> pPos <*> p <*> pPos++-- | parse located MToken+parseMToken :: LParser MToken+parseMToken = annotated MToken parseToken++-- | Parse a list of tokens and turn them into MTokens.+parseTokens :: LParser [MToken]+parseTokens = pMany parseMToken++-- | Parse the potential #!comment on the first line+-- Lua ignores the first line if it starts with #+parseHashBang :: LParser String+parseHashBang = opt (pToken "#" <* pUntilEnd) ""++-- | Lex a string with a given lexer+lexFromString :: LParser a -> String -> (a, [Error LineColPos])+lexFromString p = parse ((,) <$> p <*> pErrors <* pEnd) . createStr (LineColPos 0 0 0)++-- | Parse a string into MTokens. Also returns parse errors.+execParseTokens :: String -> ([MToken], [Error LineColPos])+execParseTokens = parse ((,) <$ parseHashBang <*> parseTokens <*> pErrors <* pEnd) . createStr (LineColPos 0 0 0)
+ src/GLua/LineLimitParser.hs view
@@ -0,0 +1,62 @@+-- | A parser that takes a maximum line length as input, and emits warnings for any line that+-- exceeds it.+module GLua.LineLimitParser where++import Control.Applicative ((<|>))+import Control.Monad (void)+import Text.Parsec (eof, satisfy, skipMany1, endOfLine, parse)+import Text.Parsec.String (Parser)+import GLua.AG.Token (Region(Region))+import GLua.PSLexer (pPos)+import GLuaFixer.LintMessage (LintMessage(..), Issue (LineTooLong), Severity (LintWarning))+++-- | The maximum line length+newtype LineLimit = LineLimit Int++execParseLineLimits :: FilePath -> LineLimit -> String -> [LintMessage]+execParseLineLimits filePath lineLimit@(LineLimit limit) contents =+  -- No point in parsing anything if the limit is 0+  if limit <= 0 then []+  else case parse (lineLimitParser filePath lineLimit) "input" contents of+    Left parseError -> error $ "Parse error while checking line limit: " ++ show parseError+    Right lintWarnings -> lintWarnings++-- | Parser that produces warnings about lines being too long+lineLimitParser :: FilePath -> LineLimit -> Parser [LintMessage]+lineLimitParser filePath lineLimit =+  [] <$ eof <|>+  recurse filePath lineLimit++-- | Recursive case of 'lineLimitParser',+recurse :: FilePath -> LineLimit -> Parser [LintMessage]+recurse filePath lineLimit@(LineLimit limit) = do+  countAtMost limit notNewline+  -- If it finds line endings, it recurses without producing warnings. Otherwise, if it finds+  -- anything else, produce a warning and still recurse.+  endOfLines *> lineLimitParser filePath lineLimit <|>+    (:) <$> lineLimitWarning filePath <*> lineLimitParser filePath lineLimit++-- | Succeeds when a character is not a line+notNewline :: Parser Char+notNewline = satisfy $ \c -> c /= '\n' && c /= '\r'++-- | end of lines. Consumes all \r and \n characters it finds+endOfLines :: Parser ()+endOfLines = skipMany1 endOfLine <|> void eof++-- | Produces a line limit warning+lineLimitWarning :: FilePath -> Parser LintMessage+lineLimitWarning filePath = do+  startPos <- pPos+  skipMany1 notNewline+  endPos <- pPos++  let warnRegion = Region startPos endPos++  pure $ LintMessage LintWarning warnRegion LineTooLong filePath++-- | Consume the parser until either it has been parsed the Int amount of times, or the parser fails+countAtMost :: Int -> Parser a -> Parser ()+countAtMost 0 _ = pure ()+countAtMost i p = p *> countAtMost (i - 1) p <|> pure ()
+ src/GLua/PSLexer.hs view
@@ -0,0 +1,338 @@+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}++module GLua.PSLexer where++import GLua.AG.Token ( Region(..), MToken(..), Token(..) )++import Data.Char(ord)+import Text.Parsec+    ( SourcePos,+      ParseError,+      char,+      anyChar,+      digit,+      endOfLine,+      noneOf,+      oneOf,+      satisfy,+      space,+      string,+      eof,+      many1,+      manyTill,+      option,+      optionMaybe,+      sourceColumn,+      sourceLine,+      (<?>),+      (<|>),+      getPosition,+      lookAhead,+      many,+      parse,+      try )+import Text.Parsec.String ( Parser )+import Text.Parsec.Pos ( newPos )+import Text.ParserCombinators.UU.BasicInstances(LineColPos(..))++-- | Region start to SourcePos+rgStart2sp :: Region -> SourcePos+rgStart2sp (Region start _) = lcp2sp start++-- | Region end to SourcePos+rgEnd2sp :: Region -> SourcePos+rgEnd2sp (Region _ end) = lcp2sp end++-- | SourcePos to region+sp2Rg :: SourcePos -> Region+sp2Rg sp = Region (sp2lcp sp) (sp2lcp sp)++-- | LineColPos to SourcePos+lcp2sp :: LineColPos -> SourcePos+lcp2sp (LineColPos l c _) = newPos "source.lua" (l + 1) (c + 1)++-- | SourcePos to LineColPos+sp2lcp :: SourcePos -> LineColPos+sp2lcp pos = LineColPos (sourceLine pos - 1) (sourceColumn pos - 1) 0++-- | Get the source position+pPos :: Parser LineColPos+pPos = sp2lcp <$> getPosition++-- See luajit's src/lj_char.c and src/lj_char.h+pIdentifierCharacter :: Parser Char+pIdentifierCharacter = satisfy validChar+    where+        validChar :: Char -> Bool+        validChar c =+            cBetween c '0' '9' ||+            cBetween c 'A' 'Z' ||+            c == '_'          ||+            cBetween c 'a' 'z' ||+            ord c >= 128+++pNonDigitIdentifierCharacter :: Parser Char+pNonDigitIdentifierCharacter = satisfy validChar+    where+        validChar :: Char -> Bool+        validChar c =+            cBetween c 'A' 'Z' ||+            c == '_'          ||+            cBetween c 'a' 'z' ||+            ord c >= 128++cBetween :: Char -> Char -> Char -> Bool+cBetween c left right = c >= left && c <= right++-- | Parse the string until the end. Used in parseLineComment among others.+pUntilEnd :: Parser String+pUntilEnd = manyTill anyChar (lookAhead (endOfLine <|> const '\n' <$> eof))++-- | Whitespace parser that requires at least one whitespace character+parseWhitespace :: Parser String+parseWhitespace = many1 space <?> "whitespace"++-- | Whitespace parser that requires 0 or more whitespace characters+parseOptionalWhitespace :: Parser String+parseOptionalWhitespace = many space <?> "whitespace"++-- | An escaped character of a single line string+-- Takes the delimiter of the string as parameter+escapedStringChar :: Char -> Parser String+escapedStringChar delim = (\escaped -> '\\' : escaped) <$ char '\\' <*> escapedChar <|> (:[]) <$> noneOf ['\n', delim]+    where+        escapedChar = (:) <$> char 'z' <*> parseOptionalWhitespace <|> (:[]) <$> anyChar++-- | The start of a nested string+-- Returns the amount of =-signs at the start of the nested string+startNestedString :: Parser String+startNestedString = do+    _ <- char '['+    depth <- many (char '=')+    _ <- char '['+    return depth++-- | Parses a multiline string+-- returns the amount of =-signs in the string delimiter and the contents+nestedString :: String -> Parser String+nestedString depth = do+    let endStr = "]" ++ depth ++ "]"+    manyTill anyChar (try $ string endStr)++-- | Parse Lua style comments+parseLuaComment :: Parser Token+parseLuaComment = do+    _ <- string "--"+    -- When a nested comment is started, it must be finished+    startNested <- optionMaybe (try startNestedString)++    case startNested of+        Nothing -> DashComment <$> pUntilEnd+        Just depth -> do+            contents <- nestedString depth+            return $ DashBlockComment (length depth) contents+++-- | Parse C-Style comments+parseCComment :: Parser Token+parseCComment = do+    _ <- char '/'+    try (SlashComment <$ char '/' <*> pUntilEnd) <|>+     SlashBlockComment <$ char '*' <*> manyTill anyChar (try (string "*/") <|> const "\n" <$> eof)++-- | Parse any kind of comment.+parseComment :: Parser Token+parseComment = parseLuaComment <|> parseCComment <?> "Comment"++-- | Convert the result of the nestedString parser to a MultiLine string+nestedStringToMLString :: String -> String -> Token+nestedStringToMLString depth contents = MLString (showChar '[' . showString depth . showChar '[' . showString contents . showChar ']' . showString depth . showChar ']' $ "")++-- | Parse single line strings e.g. "sdf", 'werf'.+parseLineString :: Char -> Parser String+parseLineString c = concat <$ char c <*> many (escapedStringChar c) <* char c++-- | Single and multiline strings.+parseString :: Parser Token+parseString = SQString <$> parseLineString '\'' <|>+              DQString <$> parseLineString '"' <|> do+                depth <- startNestedString+                nestedStringToMLString depth <$> nestedString depth <?> "String"++-- | Parse any kind of number.+-- Except for numbers that start with a '.'. That's handled by parseDots to solve ambiguity.+parseNumber :: Parser Token+parseNumber = TNumber <$> ((++) <$> (pHexadecimal <|> pBinary <|> pNumber) <*> (pLLULL <|> option "" parseNumberSuffix)) <?> "Number"+    where+        pNumber :: Parser String+        pNumber = (++) <$> many1 digit <*> option "" pDecimal++        pDecimal :: Parser String+        pDecimal = (:) <$> char '.' <*> many digit++        pHexDecimal :: Parser String+        pHexDecimal = (:) <$> char '.' <*> many pHex++        pHexadecimal :: Parser String+        pHexadecimal = (++) <$> (try (string "0x") <|> try (string "0X")) <*> ((++) <$> many1 pHex <*> option "" pHexDecimal)++        pHex :: Parser Char+        pHex = digit <|> oneOf ['a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F']++        pBinary :: Parser String+        pBinary = (++) <$> (try (string "0b") <|> try (string "0B")) <*> ((++) <$> many1 pBin <*> option "" pDecimal)++        pBin :: Parser Char+        pBin = digit <|> oneOf ['0', '1']++        -- LL/ULL suffix of a number, making it signed/unsigned int64 respectively+        -- http://luajit.org/ext_ffi_api.html#literals+        pLLULL :: Parser String+        pLLULL = pULL <|> pLL++        pLL :: Parser String+        pLL = "LL" <$ oneOf ['L', 'l'] <* oneOf ['L', 'l']++        pULL :: Parser String+        pULL = "ULL" <$ oneOf ['U', 'u'] <* pLL++-- Parse the suffix of a number+parseNumberSuffix :: Parser String+parseNumberSuffix = imaginary <|> extension+    where+        imaginary = (:[]) <$> oneOf ['i', 'I']+        extension = (\e s d -> e : s ++ d) <$> oneOf ['e', 'E', 'p', 'P']+            <*> option "" (string "+" <|> string "-")+            <*> many1 digit++-- | Parse either a keyword or an identifier that starts with that keyword+parseKeyword :: Token -> String -> Parser Token+parseKeyword tok str = try (do+    _ <- string str+    (\s -> Identifier (str ++ s)) <$> many1 (pIdentifierCharacter) <|>+        return tok+    <?> "Keyword " ++ str)++-- | Parse just an identifier.+parseIdentifier :: Parser String+parseIdentifier = (:) <$> pNonDigitIdentifierCharacter <*> many pIdentifierCharacter <?> "Identifier"++-- | Parse a label.+parseLabel :: Parser String+parseLabel = string "::" *> (optionMaybe parseWhitespace *> parseIdentifier <* optionMaybe parseWhitespace) <* string "::" <?> "Label"++-- | Parse anything to do with dots. Indexaction (.), concatenation (..), varargs (...) or numbers that start with a dot+parseDots :: Parser Token+parseDots = do+    _ <- char '.' -- first .+    try (do+        _ <- char '.' -- second .+        try (VarArg <$ char '.') <|> -- third .+            return Concatenate) <|>++        -- try to parse a number that starts with a .+        try (do+            nums <- many1 digit+            suffix <- option "" parseNumberSuffix+            return $ TNumber ('.' : (nums ++ suffix))+            ) <|>+++        return Dot++-- | Parse any kind of token.+parseToken :: Parser Token+parseToken =+                Whitespace <$> parseWhitespace                  <|>+                -- Constants+                try parseString                                 <|>+                parseNumber                                     <|>+                parseKeyword TTrue "true"                       <|>+                parseKeyword TFalse "false"                     <|>+                parseKeyword Nil "nil"                          <|>+                parseKeyword Not "not"                          <|>+                parseKeyword And "and"                          <|>+                parseKeyword Or "or"                            <|>+                parseKeyword Function "function"                <|>+                parseKeyword Local "local"                      <|>+                parseKeyword If "if"                            <|>+                parseKeyword Then "then"                        <|>+                parseKeyword Elseif "elseif"                    <|>+                parseKeyword Else "else"                        <|>+                parseKeyword For "for"                          <|>+                parseKeyword In "in"                            <|>+                parseKeyword Do "do"                            <|>+                parseKeyword While "while"                      <|>+                parseKeyword Until "until"                      <|>+                parseKeyword Repeat "repeat"                    <|>+                parseKeyword Continue "continue"                <|>+                parseKeyword Break "break"                      <|>+                parseKeyword Return "return"                    <|>+                parseKeyword End "end"                          <|>++                Identifier <$> parseIdentifier                  <|>++                Semicolon  <$ char ';'                          <|>+                parseDots                                       <|>++                try parseComment                                <|>++                -- Operators+                Plus <$ string "+"                              <|>+                Minus <$ string "-"                             <|>+                Multiply <$ string "*"                          <|>+                Divide <$ string "/"                            <|>+                Modulus <$ string "%"                           <|>+                Power <$ string "^"                             <|>+                TEq <$ try (string "==")                        <|>+                Equals <$ string "="                            <|>+                TNEq <$ string "~="                             <|>+                TCNEq <$ try (string "!=")                      <|>+                CNot <$ string "!"                              <|>+                TLEQ <$ try (string "<=")                       <|>+                TLT <$ string "<"                               <|>+                TGEQ <$ try (string ">=")                       <|>+                TGT <$ string ">"                               <|>+                Label <$> try parseLabel                        <|>+                Colon <$ string ":"                             <|>+                Comma <$ string ","                             <|>+                Hash <$ string "#"                              <|>+                CAnd <$ string "&&"                             <|>+                COr <$ string "||"                              <|>++                LRound <$ char '('                              <|>+                RRound <$ char ')'                              <|>+                LCurly <$ char '{'                              <|>+                RCurly <$ char '}'                              <|>+                LSquare <$ char '['                             <|>+                RSquare <$ char ']'+++-- | A thing of which the region is to be parsed+annotated :: (Region -> a -> b) -> Parser a -> Parser b+annotated f p = (\s t e -> f (Region s e) t) <$> pPos <*> p <*> pPos++-- | parse located MToken+parseMToken :: Parser MToken+parseMToken =+  do+    start <- pPos+    tok <- parseToken+    end <- pPos++    return $ MToken (Region start end) tok++-- | Parse a list of tokens and turn them into MTokens.+parseTokens :: Parser [MToken]+parseTokens = many parseMToken++-- | Parse the potential #!comment on the first line+-- Lua ignores the first line if it starts with #+parseHashBang :: Parser String+parseHashBang = option "" (char '#' *> pUntilEnd)++-- | Parse a string into MTokens.+execParseTokens :: String -> Either ParseError [MToken]+execParseTokens = parse (parseHashBang *> parseTokens <* eof) "input"
+ src/GLua/PSParser.hs view
@@ -0,0 +1,516 @@+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TupleSections #-}++module GLua.PSParser where++import GLua.TokenTypes+    ( isWhitespace, mpos, rgEnd, rgStart, splitComments, tokenSize )+import GLua.AG.Token+    ( Region(..),+      MToken(..),+      Token(..) )+import GLua.AG.AST+    ( AST(..),+      AReturn(..),+      Args(..),+      BinOp(..),+      Block(..),+      Expr(..),+      Field(..),+      FieldSep(..),+      FuncName(..),+      MElse(MElse),+      MElseIf(MElseIf),+      MExpr(..),+      MStat(..),+      PFExprSuffix(..),+      PrefixExp(..),+      Stat(..),+      UnOp(..) )+import qualified GLua.Lexer as Lex++import Text.Parsec+    ( SourcePos,+      ParseError,+      SourceName,+      anyToken,+      between,+      chainl1,+      choice,+      eof,+      many1,+      option,+      optionMaybe,+      sepBy1,+      incSourceColumn,+      sourceColumn,+      sourceLine,+      (<?>),+      (<|>),+      getPosition,+      getState,+      lookAhead,+      many,+      putState,+      runParser,+      tokenPrim,+      try,+      Parsec )+import Text.Parsec.Pos ( newPos )+import Text.ParserCombinators.UU.BasicInstances(LineColPos(..))++type AParser = Parsec [MToken] LineColPos+++-- | Execute a parser+execAParser :: SourceName -> AParser a -> [MToken] -> Either ParseError a+execAParser name p = runParser p (LineColPos 0 0 0) name++-- | Parse a string directly+parseFromString :: AParser a -> String -> Either ParseError a+parseFromString p = execAParser "source.lua" p . filter (not . isWhitespace) . fst . Lex.execParseTokens++-- | Parse Garry's mod Lua tokens to an abstract syntax tree.+-- Also returns parse errors+parseGLua :: [MToken] -> Either ParseError AST+parseGLua mts = let (cms, ts) = splitComments . filter (not . isWhitespace) $ mts in+                 execAParser "source.lua" (parseChunk cms) ts++parseGLuaFromString :: String -> Either ParseError AST+parseGLuaFromString contents =+    parseGLua $ filter (not . isWhitespace) $ fst $ Lex.execParseTokens contents++-- | Region start to SourcePos+rgStart2sp :: Region -> SourcePos+rgStart2sp (Region start _) = lcp2sp start++-- | Region end to SourcePos+rgEnd2sp :: Region -> SourcePos+rgEnd2sp (Region _ end) = lcp2sp end++-- | SourcePos to region+sp2Rg :: SourcePos -> Region+sp2Rg sp = Region (sp2lcp sp) (sp2lcp sp)++-- | LineColPos to SourcePos+lcp2sp :: LineColPos -> SourcePos+lcp2sp (LineColPos l c _) = newPos "source.lua" (l + 1) (c + 1)++-- | SourcePos to LineColPos+sp2lcp :: SourcePos -> LineColPos+sp2lcp pos = LineColPos (sourceLine pos - 1) (sourceColumn pos - 1) 0++-- | Update a SourcePos with an MToken+updatePosMToken :: SourcePos -> MToken -> [MToken] -> SourcePos+updatePosMToken _ (MToken p tok) [] = incSourceColumn (rgStart2sp p) (tokenSize tok)+updatePosMToken _ _ (MToken p _ : _) = rgStart2sp p++-- | Match a token+pMTok :: Token -> AParser MToken+pMTok tok =+  do+    let testMToken :: MToken -> Maybe MToken+        testMToken mt@(MToken _ t) = if t == tok then Just mt else Nothing++    mt@(MToken pos _) <- tokenPrim show updatePosMToken testMToken++    putState (rgEnd pos)++    return mt+++-- Tokens that satisfy a condition+pMSatisfy :: (MToken -> Bool) -> AParser MToken+pMSatisfy cond =+  do+    let testMToken :: MToken -> Maybe MToken+        testMToken mt = if cond mt then Just mt else Nothing++    pMToken testMToken++pMToken :: forall a. (MToken -> Maybe a) -> AParser a+pMToken cond =+  let+    testMToken :: MToken -> Maybe (MToken, a)+    testMToken mt = (mt,) <$> cond mt+  in do+    (MToken pos _, res) <- tokenPrim show updatePosMToken testMToken++    putState (rgEnd pos)++    pure res++-- | Get the source position+-- Simply gets the position of the next token+-- Falls back on the collected position when there is no token left+pPos :: AParser LineColPos+pPos = rgStart . mpos <$> lookAhead anyToken <|> sp2lcp <$> getPosition++-- | Get the source position+-- Simply gets the end position of the last parsed token+pEndPos :: AParser LineColPos+pEndPos = getState++-- | A thing of which the region is to be parsed+annotated :: (Region -> a -> b) -> AParser a -> AParser b+annotated f p = (\s t e -> f (Region s e) t) <$> pPos <*> p <*> pEndPos++-- | Parses the full AST+-- Its first parameter contains all comments+-- Assumes the mtokens fed to the AParser have no comments+parseChunk :: [MToken] -> AParser AST+parseChunk cms = AST cms <$> parseBlock <* eof++-- | Parse a block with an optional return value+parseBlock :: AParser Block+parseBlock = Block <$> pInterleaved (pMTok Semicolon) parseMStat <*> (parseReturn <|> return NoReturn)++parseMStat :: AParser MStat+parseMStat = annotated MStat parseStat++-- | Parser that is interleaved with 0 or more of the other parser+pInterleaved :: AParser a -> AParser b -> AParser [b]+pInterleaved sep q = many sep *> many (q <* many sep)++-- | Parse a return value+parseReturn :: AParser AReturn+parseReturn = annotated AReturn (pMTok Return *> option [] parseExpressionList <* many (pMTok Semicolon) <?> "return statement")++-- | Label+parseLabel :: AParser MToken+parseLabel = pMSatisfy isLabel <?> "label"+    where+        isLabel :: MToken -> Bool+        isLabel (MToken _ (Label _)) = True+        isLabel _ = False++-- | Parse a single statement+parseStat :: AParser Stat+parseStat = ALabel <$> parseLabel <|>+            ABreak <$ pMTok Break <|>+            AContinue <$ pMTok Continue <|>+            ADo <$ pMTok Do <*> parseBlock <* pMTok End <|>+            AWhile <$ pMTok While <*> parseExpression <* pMTok Do <*> parseBlock <* pMTok End <|>+            ARepeat <$ pMTok Repeat <*> parseBlock <* pMTok Until <*> parseExpression <|>+            parseIf <|>+            parseFunction <|>+            parseFor <|>+            try (AGoto <$ pMTok (Identifier "goto") <*> pName) <|>+            parseDefinition <|>+            AFuncCall <$> pFunctionCall <|>+            pMTok Local *>+                (parseLocalDefinition <|>+                parseLocalFunction)+++-- | Global definition+-- Note: Uses try to avoid conflicts with function calls+parseDefinition :: AParser Stat+parseDefinition = flip (<?>) "variable definition" $ do+    vars <- try $ do+        vs <- parseVarList+        _ <- pMTok Equals+        return vs++    exprs <- parseExpressionList++    return $ Def (zip vars (map Just exprs ++ repeat Nothing))++-- | Local definition+parseLocalDefinition :: AParser Stat+parseLocalDefinition = def <$> parseLocalVarList <*> option [] (pMTok Equals *> parseExpressionList) <?> "variable declaration"+    where+        def :: [PrefixExp] -> [MExpr] -> Stat+        def ps exs = LocDef $ zip ps (map Just exs ++ repeat Nothing)++-- | Global function definition+parseFunction :: AParser Stat+parseFunction = AFunc <$ pMTok Function <*> parseFuncName <*>+                     between (pMTok LRound) (pMTok RRound) parseParList <*>+                     parseBlock <*+                     pMTok End <?> "function definition"++-- | Local function definition+parseLocalFunction :: AParser Stat+parseLocalFunction = ALocFunc <$ pMTok Function <*> parseLocFuncName <*>+                     between (pMTok LRound) (pMTok RRound) parseParList <*>+                     parseBlock <*+                     pMTok End <?> "local function definition"++-- | Parse if then elseif then else end expressions+parseIf :: AParser Stat+parseIf = AIf <$ pMTok If <*> parseExpression <* pMTok Then <*>+            parseBlock <*>+            -- elseif+            many (annotated MElseIf $ (,) <$ pMTok Elseif <*> parseExpression <* pMTok Then <*> parseBlock) <*>+            -- else+            optionMaybe (annotated MElse $ pMTok Else *> parseBlock) <*+            pMTok End <?> "if statement"++parseFor :: AParser Stat+parseFor = parseNFor <|> parseGFor++-- | Parse numeric for loop+parseNFor :: AParser Stat+parseNFor = flip (<?>) "numeric for loop" $+    do+        name <- try $ do+            _ <- pMTok For+            name <- pName+            _ <- pMTok Equals+            return name++        start <- parseExpression+        _ <- pMTok Comma+        to <- parseExpression+        st <- step+        _ <- pMTok Do+        blk <- parseBlock+        _ <- pMTok End++        return $ ANFor name start to st blk+    where+        step :: AParser MExpr+        step = pMTok Comma *> parseExpression <|> annotated MExpr (return (ANumber "1"))++-- | Generic for loop+parseGFor :: AParser Stat+parseGFor = AGFor <$ pMTok For <*> parseNameList <* pMTok In <*> parseExpressionList <* pMTok Do <*> parseBlock <* pMTok End <?> "generic for loop"++-- | Function name (includes dot indices and meta indices)+parseFuncName :: AParser FuncName+parseFuncName = (\a b c -> FuncName (a:b) c) <$> pName <*> many (pMTok Dot *> pName) <*>+                option Nothing (Just <$ pMTok Colon <*> pName) <?> "function name"++-- | Local function name: cannot be a meta function nor indexed+parseLocFuncName :: AParser FuncName+parseLocFuncName = (\name -> FuncName [name] Nothing) <$> pName <?> "function name"++-- | Parse a number into an expression+parseNumber :: AParser Expr+parseNumber = pMToken isNumber <?> "number"+    where+        isNumber :: MToken -> Maybe Expr+        isNumber = \case+            MToken _ (TNumber str) -> Just $ ANumber str+            _ -> Nothing++-- | Parse any kind of string+parseString :: AParser MToken+parseString = pMSatisfy isString <?> "string"+    where+        isString :: MToken -> Bool+        isString (MToken _ (DQString _)) = True+        isString (MToken _ (SQString _)) = True+        isString (MToken _ (MLString _)) = True+        isString _ = False++-- | Parse an identifier+pName :: AParser MToken+pName = pMSatisfy isName <?> "identifier"+    where+        isName :: MToken -> Bool+        isName (MToken _ (Identifier _)) = True+        isName _ = False++-- | Parse a list of identifiers+parseNameList :: AParser [MToken]+parseNameList = sepBy1 pName (pMTok Comma)++-- | Parse variable list (var1, var2, var3)+parseVarList :: AParser [PrefixExp]+parseVarList = sepBy1 parseVar (pMTok Comma)++-- | Parse local variable list (var1, var2, var3)+parseLocalVarList :: AParser [PrefixExp]+parseLocalVarList = sepBy1 (PFVar <$> pName <*> pure []) (pMTok Comma)++-- | Parse list of function parameters+parseParList :: AParser [MToken]+parseParList = option [] $ nameParam <|> vararg+    where+        vararg = (:[]) <$> pMTok VarArg <?> "..."+        nameParam = (:) <$> pName <*> moreParams <?> "parameter"+        moreParams = option [] $ pMTok Comma *> (nameParam <|> vararg)++-- | list of expressions+parseExpressionList :: AParser [MExpr]+parseExpressionList = sepBy1 parseExpression (pMTok Comma)++-- | Subexpressions, i.e. without operators+parseSubExpression :: AParser Expr+parseSubExpression = ANil <$ pMTok Nil <|>+                  AFalse <$ pMTok TFalse <|>+                  ATrue <$ pMTok TTrue <|>+                  parseNumber <|>+                  AString <$> parseString <|>+                  AVarArg <$ pMTok VarArg <|>+                  parseAnonymFunc <|>+                  APrefixExpr <$> parsePrefixExp <|>+                  ATableConstructor <$> parseTableConstructor <?> "expression"+++-- | Separate parser for anonymous function subexpression+parseAnonymFunc :: AParser Expr+parseAnonymFunc = AnonymousFunc <$+                   pMTok Function <*+                   pMTok LRound <*> parseParList <* pMTok RRound <*>+                   parseBlock <*+                   pMTok End <?> "anonymous function"++-- | Parse operators of the same precedence in a chain+samePrioL :: [(Token, BinOp)] -> AParser MExpr -> AParser MExpr+samePrioL ops pr = chainl1 pr (choice (map f ops))+  where+    f :: (Token, BinOp) -> AParser (MExpr -> MExpr -> MExpr)+    f (t, at) = annotated (\p _ e1 e2 -> MExpr p (BinOpExpr at e1 e2)) (pMTok t)++samePrioR :: [(Token, BinOp)] -> AParser MExpr -> AParser MExpr+samePrioR ops pr = chainl1 pr (choice (map f ops))+  where+    f :: (Token, BinOp) -> AParser (MExpr -> MExpr -> MExpr)+    f (t, at) = annotated (\p _ e1 e2 -> MExpr p (BinOpExpr at e1 e2)) (pMTok t)++-- | Parse unary operator (-, not, #)+parseUnOp :: AParser UnOp+parseUnOp = UnMinus <$ pMTok Minus <|>+            ANot    <$ pMTok Not   <|>+            ANot    <$ pMTok CNot  <|>+            AHash   <$ pMTok Hash++-- | Parses a binary operator+parseBinOp :: AParser BinOp+parseBinOp = AOr          <$ pMTok Or           <|>+             AOr          <$ pMTok COr          <|>+             AAnd         <$ pMTok And          <|>+             AAnd         <$ pMTok CAnd         <|>+             ALT          <$ pMTok TLT          <|>+             AGT          <$ pMTok TGT          <|>+             ALEQ         <$ pMTok TLEQ         <|>+             AGEQ         <$ pMTok TGEQ         <|>+             ANEq         <$ pMTok TNEq         <|>+             ANEq         <$ pMTok TCNEq        <|>+             AEq          <$ pMTok TEq          <|>+             AConcatenate <$ pMTok Concatenate  <|>+             APlus        <$ pMTok Plus         <|>+             BinMinus     <$ pMTok Minus        <|>+             AMultiply    <$ pMTok Multiply     <|>+             ADivide      <$ pMTok Divide       <|>+             AModulus     <$ pMTok Modulus      <|>+             APower       <$ pMTok Power++-- | Operators, sorted by priority+-- Priority from: http://www.lua.org/manual/5.2/manual.html#3.4.7+lvl1, lvl2, lvl3, lvl4, lvl5, lvl6, lvl8 :: [(Token, BinOp)]+lvl1 = [(Or, AOr), (COr, AOr)]+lvl2 = [(And, AAnd), (CAnd, AAnd)]+lvl3 = [(TLT, ALT), (TGT, AGT), (TLEQ, ALEQ), (TGEQ, AGEQ), (TNEq, ANEq), (TCNEq, ANEq), (TEq, AEq)]+lvl4 = [(Concatenate, AConcatenate)]+lvl5 = [(Plus, APlus), (Minus, BinMinus)]+lvl6 = [(Multiply, AMultiply), (Divide, ADivide), (Modulus, AModulus)]+-- lvl7 is unary operators+lvl8 = [(Power, APower)]+++-- | Parse chains of binary and unary operators+parseExpression :: AParser MExpr+parseExpression =  samePrioL lvl1+                  (samePrioL lvl2 $+                   samePrioL lvl3 $+                   samePrioR lvl4 $+                   samePrioL lvl5 $+                   samePrioL lvl6 $+                   annotated MExpr (UnOpExpr <$> parseUnOp <*> parseExpression) <|> -- lvl7+                   samePrioR lvl8 (annotated MExpr (parseSubExpression <|> UnOpExpr <$> parseUnOp <*> parseExpression))) <?> "expression"++-- | Prefix expressions+-- can have any arbitrary list of expression suffixes+parsePrefixExp :: AParser PrefixExp+parsePrefixExp = pPrefixExp (many pPFExprSuffix)++-- | Prefix expressions+-- The suffixes define rules on the allowed suffixes+pPrefixExp :: AParser [PFExprSuffix] -> AParser PrefixExp+pPrefixExp suffixes = PFVar <$> pName <*> suffixes <|>+                      ExprVar <$ pMTok LRound <*> parseExpression <* pMTok RRound <*> suffixes++-- | Parse any expression suffix+pPFExprSuffix :: AParser PFExprSuffix+pPFExprSuffix = pPFExprCallSuffix <|> pPFExprIndexSuffix++-- | Parse an indexing expression suffix+pPFExprCallSuffix :: AParser PFExprSuffix+pPFExprCallSuffix = Call <$> parseArgs <|>+                    MetaCall <$ pMTok Colon <*> pName <*> parseArgs <?> "function call"++-- | Parse an indexing expression suffix+pPFExprIndexSuffix :: AParser PFExprSuffix+pPFExprIndexSuffix = ExprIndex <$ pMTok LSquare <*> parseExpression <* pMTok RSquare <|>+                     DotIndex <$ pMTok Dot <*> pName <?> "indexation"++-- | Function calls are prefix expressions, but the last suffix MUST be either a function call or a metafunction call+pFunctionCall :: AParser PrefixExp+pFunctionCall = pPrefixExp suffixes <?> "function call"+    where+        suffixes = concat <$> many1 ((\ix c -> ix ++ [c]) <$> many1 pPFExprIndexSuffix <*> pPFExprCallSuffix <|>+                                     (:[])                <$> pPFExprCallSuffix)++-- | single variable. Note: definition differs from reference to circumvent the left recursion+-- var ::= Name [{PFExprSuffix}* indexation] | '(' exp ')' {PFExprSuffix}* indexation+-- where "{PFExprSuffix}* indexation" is any arbitrary sequence of prefix expression suffixes that end with an indexation+parseVar :: AParser PrefixExp+parseVar = pPrefixExp suffixes <?> "variable"+    where+        suffixes = concat <$> many ((\c ix -> c ++ [ix]) <$> many1 pPFExprCallSuffix <*> pPFExprIndexSuffix <|>+                                    (:[])                <$> pPFExprIndexSuffix)++-- | Arguments of a function call (including brackets)+parseArgs :: AParser Args+parseArgs = ListArgs <$ pMTok LRound <*> option [] parseExpressionList <* pMTok RRound <|>+            TableArg <$> parseTableConstructor <|>+            StringArg <$> parseString <?> "function arguments"++-- | Table constructor+parseTableConstructor :: AParser [Field]+parseTableConstructor = pMTok LCurly *> parseFieldList <* pMTok RCurly <?> "table"++-- | A list of table entries+-- Grammar: field {separator field} [separator]+parseFieldList :: AParser [Field]+parseFieldList = option [] $ do+    field <- parseField+    sep <- parseOptionalFieldSep+    case sep of+        NoSep -> pure [field NoSep]+        _ -> (field sep :) <$> parseFieldList++-- | Parse a named field (e.g. {named = field})+-- Contains try to avoid conflict with unnamed fields+parseNamedField :: AParser (FieldSep -> Field)+parseNamedField = do+    name <- try $ do+        n <- pName+        _ <- pMTok Equals+        return n++    NamedField name <$> parseExpression++-- | A field in a table+parseField :: AParser (FieldSep -> Field)+parseField = ExprField <$ pMTok LSquare <*> parseExpression <* pMTok RSquare <* pMTok Equals <*> parseExpression <|>+             parseNamedField <|>+             UnnamedField <$> parseExpression <?> "field"++-- | Field separator, either comma or semicolon+parseFieldSep :: AParser FieldSep+parseFieldSep =+    CommaSep <$ pMTok Comma <|>+    SemicolonSep <$ pMTok Semicolon++-- | Optional field separator, returns NoSep when no separator is found+-- Used at the end of a field list+parseOptionalFieldSep :: AParser FieldSep+parseOptionalFieldSep = option NoSep parseFieldSep
+ src/GLua/Parser.hs view
@@ -0,0 +1,523 @@+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE NoMonomorphismRestriction #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE LambdaCase #-}++-- | Parser based on <http://www.lua.org/manual/5.2/manual.html#9>+module GLua.Parser where++import GLua.TokenTypes+import GLua.AG.Token+import GLua.AG.AST+import qualified GLua.Lexer as Lex++import Text.ParserCombinators.UU+import Text.ParserCombinators.UU.BasicInstances++-- | MTokens with the positions of the next MToken (used in the advance of parser)+data MTokenPos = MTokenPos MToken Region++data RegionProgression =+  RegionProgression {lastRegion :: Region, nextRegion :: Region}+  deriving (Show)++emptyRgPrgs :: RegionProgression+emptyRgPrgs = RegionProgression emptyRg emptyRg++instance Show MTokenPos where+  show (MTokenPos tok _) = show tok++-- | Custom parser that parses MTokens+type AParser a = P (Str MTokenPos [MTokenPos] RegionProgression) a++-- | RegionProgression is a location that can be updated by MTokens+instance IsLocationUpdatedBy RegionProgression MTokenPos where+    -- advance :: RegionProgression -> MToken -> RegionProgression+    -- Assume the position of the next MToken+    advance _ (MTokenPos mt p) = RegionProgression (mpos mt) p++resultsToRegion :: (a, [Error RegionProgression]) -> (a, [Error Region])+resultsToRegion (a, errs) = (a, map errorToRegion errs)++-- | Parse Garry's mod Lua tokens to an abstract syntax tree.+-- Also returns parse errors+parseGLua :: [MToken] -> (AST, [Error Region])+parseGLua mts =+  let+    (cms, ts) = splitComments . filter (not . isWhitespace) $ mts+  in+    resultsToRegion $ execAParser (parseChunk cms) ts++-- | Parse a string directly into an AST+parseGLuaFromString :: String -> (AST, [Error Region])+parseGLuaFromString = parseGLua . filter (not . isWhitespace) . fst . Lex.execParseTokens++-- | Parse a string directly+parseFromString :: AParser a -> String -> (a, [Error Region])+parseFromString p = resultsToRegion . execAParser p . filter (not . isWhitespace) . fst . Lex.execParseTokens++-- | Create a parsable string from MTokens+createString :: [MToken] -> Str MTokenPos [MTokenPos] RegionProgression+createString [] = createStr emptyRgPrgs []+createString mts@(MToken p _ : xs) = createStr (RegionProgression p (nextRg mts')) mtpos where+    mts' = xs ++ [last mts] -- Repeat last element of mts+    mkMtPos mt (MToken p' _) = MTokenPos mt p'+    mtpos = zipWith mkMtPos mts mts'++    nextRg (MToken p' _ : _) = p'+    nextRg [] = undefined+++errorToRegion :: Error RegionProgression -> Error Region+errorToRegion (Inserted a p b) = Inserted a (nextRegion p) b+errorToRegion (Deleted a p b) = Deleted a (nextRegion p) b+errorToRegion (Replaced a b p c) = Replaced a b (nextRegion p) c+errorToRegion (DeletedAtEnd s) = DeletedAtEnd s++-- | Position in Region (as opposed to RegionProgression)+pPos' :: AParser Region+pPos' = nextRegion <$> pPos++-- | Text.ParserCombinators.UU.Utils.execParser modified to parse MTokens+-- The first MToken might not be on the first line, so use the first MToken's position to start+execAParser :: AParser a -> [MToken] -> (a, [Error RegionProgression])+execAParser p mts@[] = parse_h ((,) <$> p <*> pEnd) . createString $ mts+execAParser p mts@(_ : _) = parse_h ((,) <$> p <*> pEnd) . createString $ mts -- createStr (mpos m) $ mts+++pMSatisfy :: (MToken -> Bool) -> Token -> String -> AParser MToken+pMSatisfy f t ins = getToken <$> pSatisfy f' (Insertion ins (MTokenPos (MToken ep t) ep) 5) where+    f' :: MTokenPos -> Bool+    f' (MTokenPos tok _) = f tok++    getToken :: MTokenPos -> MToken+    getToken (MTokenPos t' _) = t'++    ep = Region (LineColPos 0 0 0) (LineColPos 0 0 0)++-- | Parse a single Metatoken, based on a positionless token (much like pSym)+pMTok :: Token -> AParser MToken+pMTok t = pMSatisfy isToken t $ "'" ++ show t ++ "'"+    where+        isToken :: MToken -> Bool+        isToken (MToken _ tok) = t == tok++-- | Parse a list of identifiers+parseNameList :: AParser [MToken]+parseNameList = (:) <$> pName <*> pMany (pMTok Comma *> pName)++-- | Parse list of function parameters+parseParList :: AParser [MToken]+parseParList = (pMTok VarArg <<|> pName) <**> (+                    pMTok Comma <**> (+                        (\a _ c -> [c, a]) <$> pMTok VarArg <<|>+                        (\a _ c -> c : a)  <$> parseParList+                    ) `opt` (: [])+               ) `opt` []++-- | Parses the full AST+-- Its first parameter contains all comments+-- Assumes the mtokens fed to the AParser have no comments+parseChunk :: [MToken] -> AParser AST+parseChunk cms = AST cms <$> parseBlock++-- | Parse a block with an optional return value+parseBlock :: AParser Block+parseBlock = Block <$> pInterleaved (pMTok Semicolon) parseMStat <*> (parseReturn <<|> pReturn NoReturn)+++-- | A thing of which the region is to be parsed+annotated :: (Region -> a -> b) -> AParser a -> AParser b+annotated f p = (\s t e -> f (Region (rgStart s) (rgEnd $ lastRegion $ pos $ e)) t) <$> pPos' <*> p <*> pState++parseMStat :: AParser MStat+parseMStat = annotated MStat parseStat++-- | Parser that is interleaved with 0 or more of the other parser+pInterleaved :: AParser a -> AParser b -> AParser [b]+pInterleaved sep q = pMany sep *> pMany (q <* pMany sep)++-- | Behemoth parser that parses either function call statements or global declaration statements+-- Big in size and complexity because prefix expressions are BITCHES+-- The problem lies in the complexity of prefix expressions:+-- hotten.totten["tenten"](tentoonstelling) -- This is a function call+-- hotten.totten["tenten"] = tentoonstelling -- This is a declaration.+-- hotten.totten["tenten"], tentoonstelling = 1, 2 -- This is also a declaration.+-- One may find an arbitrary amount of expression suffixes (indexations/calls) before+-- finding a comma or equals sign that proves that it is a declaration.+-- Also, goto can be an identifier+parseCallDef :: AParser Stat+parseCallDef = parseGoto <<|>+               (PFVar <$> pName <<|> -- Statemens begin with either a simple name or parenthesised expression+                ExprVar <$ pMTok LRound <*> parseExpression <* pMTok RRound) <**> (+                  -- Either there are more suffixes yet to be found (contSearch)+                  -- or there aren't and we will find either a comma or =-sign (varDecl namedVarDecl)+                  contSearch <<|>+                  varDecl namedVarDecl+                )+  where+    -- Try to parse a goto statement+    parseGoto :: AParser Stat+    parseGoto = (PFVar <$> pMTok (Identifier "goto")) <**>+                  ((\n _ -> AGoto n) <$> pName <<|>+                    contSearch <<|>+                    varDecl namedVarDecl)++    -- Simple direct declaration: varName, ... = 1, ...+    namedVarDecl :: [PrefixExp] -> [MExpr] -> (ExprSuffixList -> PrefixExp) -> Stat+    namedVarDecl vars exprs pfe = let pfes = (pfe []) : vars in Def (zip pfes $ map Just exprs ++ repeat Nothing)++    -- This is where we know it's a variable declaration+    -- Takes a function that turns it into a proper Def Stat+    varDecl :: ([PrefixExp] -> [MExpr] -> b) -> AParser b+    varDecl f = f <$> opt (pMTok Comma *> parseVarList) [] <*+              pMTok Equals <*>+              parseExpressionList++    -- We know that there is at least one suffix (indexation or call).+    -- Search for more suffixes and make either a call or declaration from it+    contSearch :: AParser ((ExprSuffixList -> PrefixExp) -> Stat)+    contSearch = (\(ss, mkStat) pfe -> mkStat $ pfe ss) <$> searchDeeper++    -- We either find a call suffix or an indexation suffix+    -- When it's a function call, try searching for more suffixes, if that doesn't work, it's a function call.+    -- When it's an indexation suffix, search for more suffixes or know that it's a declaration.+    searchDeeper :: AParser ([PFExprSuffix], PrefixExp -> Stat)+    searchDeeper = (pPFExprCallSuffix <**> (mergeDeeperSearch <$> searchDeeper <<|> pReturn (\s -> ([s], AFuncCall)))) <<|>+                   (pPFExprIndexSuffix <**> (mergeDeeperSearch <$> searchDeeper <<|> varDecl complexDecl))++    -- Merge the finding of more suffixes with the currently found suffix+    mergeDeeperSearch :: ([PFExprSuffix], PrefixExp -> Stat) -> PFExprSuffix -> ([PFExprSuffix], PrefixExp -> Stat)+    mergeDeeperSearch (ss, f) s = (s : ss, f)++    -- Multiple suffixes have been found, and proof has been found that this must be a declaration.+    -- Now to give all the collected suffixes and a function that creates the declaration+    complexDecl :: [PrefixExp] -> [MExpr] -> PFExprSuffix -> ([PFExprSuffix], PrefixExp -> Stat)+    complexDecl vars exprs s = ([s], \pf -> Def (zip (pf : vars) $ map Just exprs ++ repeat Nothing))+++-- | Parse a single statement+parseStat :: AParser Stat+parseStat = parseCallDef <<|>+            ALabel <$> parseLabel <<|>+            ABreak <$ pMTok Break <<|>+            AContinue <$ pMTok Continue <<|>+            --AGoto <$ pMTok (Identifier "goto") <*> pName <|>+            ADo <$ pMTok Do <*> parseBlock <* pMTok End <<|>+            AWhile <$ pMTok While <*> parseExpression <* pMTok Do <*> parseBlock <* pMTok End <<|>+            ARepeat <$ pMTok Repeat <*> parseBlock <* pMTok Until <*> parseExpression <<|>+            parseIf <<|>+            parseFor <<|>+            AFunc <$ pMTok Function <*> parseFuncName <*>+             pPacked (pMTok LRound) (pMTok RRound) parseParList <*>+             parseBlock <*+             pMTok End <<|>+            -- local function and local vars both begin with "local"+            pMTok Local <**> (+              -- local function+              (\n p b _l -> ALocFunc n p b) <$+                pMTok Function <*> parseLocFuncName <*> pPacked (pMTok LRound) (pMTok RRound) parseParList <*>+                parseBlock <* pMTok End <<|>+              -- local variables+              (\v (_p, e) _l -> LocDef (zip v $ map Just e ++ repeat Nothing)) <$> parseLocalVarList <*> ((,) <$ pMTok Equals <*> pPos' <*> parseExpressionList <<|> (,) <$> pPos' <*> pReturn [])+            )+++-- | Parse if then elseif then else end expressions+parseIf :: AParser Stat+parseIf = AIf <$ pMTok If <*> parseExpression <* pMTok Then <*>+            parseBlock <*>+            -- elseif+            pMany (annotated MElseIf $ (,) <$ pMTok Elseif <*> parseExpression <* pMTok Then <*> parseBlock) <*>+            -- else+            optional (annotated MElse $ pMTok Else *> parseBlock) <*+            pMTok End++-- | Parse numeric and generic for loops+parseFor :: AParser Stat+parseFor = do+  pMTok For+  firstName <- pName+  -- If you see an =-sign, it's a numeric for loop. It'll be a generic for loop otherwise+  isNumericLoop <- (const True <$> pMTok Equals <<|> const False <$> pReturn ())+  if isNumericLoop then do+      startExp <- parseExpression+      pMTok Comma+      toExp <- parseExpression+      step <- pMTok Comma *> parseExpression <<|> MExpr <$> pPos' <*> pReturn (ANumber "1")+      pMTok Do+      block <- parseBlock+      pMTok End+      pReturn $ ANFor firstName startExp toExp step block+  else do+     vars <- (:) firstName <$ pMTok Comma <*> parseNameList <<|> pReturn [firstName]+     pMTok In+     exprs <- parseExpressionList+     pMTok Do+     block <- parseBlock+     pMTok End+     pReturn $ AGFor vars exprs block+++-- | Parse a return value+parseReturn :: AParser AReturn+parseReturn = AReturn <$> pPos' <* pMTok Return <*> opt parseExpressionList [] <* pMany (pMTok Semicolon)++-- | Label+parseLabel :: AParser MToken+parseLabel = pMSatisfy isLabel (Label "someLabel") "Some label"+    where+        isLabel :: MToken -> Bool+        isLabel (MToken _ (Label _)) = True+        isLabel _ = False++-- | Function name (includes dot indices and meta indices)+parseFuncName :: AParser FuncName+parseFuncName = (\a b c -> FuncName (a:b) c) <$> pName <*> pMany (pMTok Dot *> pName) <*>+                opt (Just <$ pMTok Colon <*> pName) Nothing++-- | Local function name. Does not include dot and meta indices, since they're not allowed in meta functions+parseLocFuncName :: AParser FuncName+parseLocFuncName = (\a -> FuncName [a] Nothing) <$> pName++-- | Parse a number into an expression+parseNumber :: AParser Expr+parseNumber = toAnumber <$> pMSatisfy isNumber (TNumber "0") "Number"+    where+        isNumber :: MToken -> Bool+        isNumber (MToken _ (TNumber _)) = True+        isNumber _ = False++        -- A better solution would be to have a single `MToken -> Maybe Expr` function, but I am too+        -- lazy to write that.+        toAnumber :: MToken -> Expr+        toAnumber = \case+          (MToken _ (TNumber str)) -> ANumber str+          _ -> error "unreachable"++-- | Parse any kind of string+parseString :: AParser MToken+parseString = pMSatisfy isString (DQString "someString") "String"+    where+        isString :: MToken -> Bool+        isString (MToken _ (DQString _)) = True+        isString (MToken _ (SQString _)) = True+        isString (MToken _ (MLString _)) = True+        isString _ = False++-- | Parse an identifier+pName :: AParser MToken+pName = pMSatisfy isName (Identifier "someVariable") "Variable"+    where+        isName :: MToken -> Bool+        isName (MToken _ (Identifier _)) = True+        isName _ = False++-- | Parse variable list (var1, var2, var3)+parseVarList :: AParser [PrefixExp]+parseVarList = pList1Sep (pMTok Comma) parseVar++-- | Parse local variable list (var1, var2, var3), without suffixes+parseLocalVarList :: AParser [PrefixExp]+parseLocalVarList = pList1Sep (pMTok Comma) (PFVar <$> pName <*> pure [])++-- | list of expressions+parseExpressionList :: AParser [MExpr]+parseExpressionList = pList1Sep (pMTok Comma) parseExpression++-- | Subexpressions, i.e. without operators+parseSubExpression :: AParser Expr+parseSubExpression = ANil <$ pMTok Nil <<|>+                  AFalse <$ pMTok TFalse <<|>+                  ATrue <$ pMTok TTrue <<|>+                  parseNumber <<|>+                  AString <$> parseString <<|>+                  AVarArg <$ pMTok VarArg <<|>+                  parseAnonymFunc <<|>+                  APrefixExpr <$> parsePrefixExp <<|>+                  ATableConstructor <$> parseTableConstructor++-- | Separate parser for anonymous function subexpression+parseAnonymFunc :: AParser Expr+parseAnonymFunc = AnonymousFunc <$+                   pMTok Function <*>+                   pPacked (pMTok LRound) (pMTok RRound) parseParList <*>+                   parseBlock <*+                   pMTok End++-- | Parse operators of the same precedence in a chain+samePrioL :: [(Token, BinOp)] -> AParser MExpr -> AParser MExpr+samePrioL ops pr = pChainl (choice (map f ops)) pr+  where+    choice = foldr (<<|>) pFail+    f :: (Token, BinOp) -> AParser (MExpr -> MExpr -> MExpr)+    f (t, at) = (\p e1 e2 -> MExpr p (BinOpExpr at e1 e2)) <$> pPos' <* pMTok t++samePrioR :: [(Token, BinOp)] -> AParser MExpr -> AParser MExpr+samePrioR ops pr = pChainr (choice (map f ops)) pr+  where+    choice = foldr (<<|>) pFail+    f :: (Token, BinOp) -> AParser (MExpr -> MExpr -> MExpr)+    f (t, at) = (\p e1 e2 -> MExpr p (BinOpExpr at e1 e2)) <$> pPos' <* pMTok t++-- | Parse unary operator (-, not, #)+parseUnOp :: AParser UnOp+parseUnOp = UnMinus <$ pMTok Minus <<|>+            ANot    <$ pMTok Not   <<|>+            ANot    <$ pMTok CNot  <<|>+            AHash   <$ pMTok Hash++-- | Operators, sorted by priority+-- Priority from: http://www.lua.org/manual/5.2/manual.html#3.4.7+lvl1, lvl2, lvl3, lvl4, lvl5, lvl6, lvl8 :: [(Token, BinOp)]+lvl1 = [(Or, AOr), (COr, AOr)]+lvl2 = [(And, AAnd), (CAnd, AAnd)]+lvl3 = [(TLT, ALT), (TGT, AGT), (TLEQ, ALEQ), (TGEQ, AGEQ), (TNEq, ANEq), (TCNEq, ANEq), (TEq, AEq)]+lvl4 = [(Concatenate, AConcatenate)]+lvl5 = [(Plus, APlus), (Minus, BinMinus)]+lvl6 = [(Multiply, AMultiply), (Divide, ADivide), (Modulus, AModulus)]+-- lvl7 is unary operators+lvl8 = [(Power, APower)]+++-- | Parse chains of binary and unary operators+parseExpression :: AParser MExpr+parseExpression = samePrioL lvl1 $+                  samePrioL lvl2 $+                  samePrioL lvl3 $+                  samePrioR lvl4 $+                  samePrioL lvl5 $+                  samePrioL lvl6 $+                  MExpr <$> pPos' <*> (UnOpExpr <$> parseUnOp <*> parseExpression) <<|> -- lvl7+                  samePrioR lvl8 (MExpr <$> pPos' <*> (parseSubExpression <|> UnOpExpr <$> parseUnOp <*> parseExpression))++-- | Parses a binary operator+parseBinOp :: AParser BinOp+parseBinOp = const AOr          <$> pMTok Or           <<|>+             const AOr          <$> pMTok COr          <<|>+             const AAnd         <$> pMTok And          <<|>+             const AAnd         <$> pMTok CAnd         <<|>+             const ALT          <$> pMTok TLT          <<|>+             const AGT          <$> pMTok TGT          <<|>+             const ALEQ         <$> pMTok TLEQ         <<|>+             const AGEQ         <$> pMTok TGEQ         <<|>+             const ANEq         <$> pMTok TNEq         <<|>+             const ANEq         <$> pMTok TCNEq        <<|>+             const AEq          <$> pMTok TEq          <<|>+             const AConcatenate <$> pMTok Concatenate  <<|>+             const APlus        <$> pMTok Plus         <<|>+             const BinMinus     <$> pMTok Minus        <<|>+             const AMultiply    <$> pMTok Multiply     <<|>+             const ADivide      <$> pMTok Divide       <<|>+             const AModulus     <$> pMTok Modulus      <<|>+             const APower       <$> pMTok Power+++-- | Prefix expressions+-- can have any arbitrary list of expression suffixes+parsePrefixExp :: AParser PrefixExp+parsePrefixExp = pPrefixExp (pMany pPFExprSuffix)++-- | Prefix expressions+-- The suffixes define rules on the allowed suffixes+pPrefixExp :: AParser [PFExprSuffix] -> AParser PrefixExp+pPrefixExp suffixes = PFVar <$> pName <*> suffixes <<|>+                      ExprVar <$ pMTok LRound <*> parseExpression <* pMTok RRound <*> suffixes++-- | Parse any expression suffix+pPFExprSuffix :: AParser PFExprSuffix+pPFExprSuffix = pPFExprCallSuffix <<|> pPFExprIndexSuffix++-- | Parse an indexing expression suffix+pPFExprCallSuffix :: AParser PFExprSuffix+pPFExprCallSuffix = Call <$> parseArgs <<|>+                    MetaCall <$ pMTok Colon <*> pName <*> parseArgs++-- | Parse an indexing expression suffix+pPFExprIndexSuffix :: AParser PFExprSuffix+pPFExprIndexSuffix = ExprIndex <$ pMTok LSquare <*> parseExpression <* pMTok RSquare <<|>+                     DotIndex <$ pMTok Dot <*> pName++-- | Function calls are prefix expressions, but the last suffix MUST be either a function call or a metafunction call+pFunctionCall :: AParser PrefixExp+pFunctionCall = pPrefixExp suffixes+    where+        suffixes = concat <$> pSome ((\ix c -> ix ++ [c]) <$> pSome pPFExprIndexSuffix <*> pPFExprCallSuffix <<|>+                                     (:[])                <$> pPFExprCallSuffix)++-- | single variable. Note: definition differs from reference to circumvent the left recursion+-- var ::= Name [{PFExprSuffix}* indexation] | '(' exp ')' {PFExprSuffix}* indexation+-- where "{PFExprSuffix}* indexation" is any arbitrary sequence of prefix expression suffixes that end with an indexation+parseVar :: AParser PrefixExp+parseVar = pPrefixExp suffixes+    where+        suffixes = concat <$> pMany ((\c ix -> c ++ [ix]) <$> pSome pPFExprCallSuffix <*> pPFExprIndexSuffix <<|>+                                     (:[])                <$> pPFExprIndexSuffix)++-- | Arguments of a function call (including brackets)+parseArgs :: AParser Args+parseArgs = ListArgs <$ pMTok LRound <*> opt parseExpressionList [] <* pMTok RRound <<|>+            TableArg <$> parseTableConstructor <<|>+            StringArg <$> parseString++-- | Table constructor+parseTableConstructor :: AParser [Field]+parseTableConstructor = pMTok LCurly *> parseFieldList <* pMTok RCurly++-- | A list of table entries+-- Grammar: field {separator field} [separator]+parseFieldList :: AParser [Field]+parseFieldList =+    parseField <**>+      ( parseFieldSep <**>+          ((\rest sep field -> field sep : rest) <$> (parseFieldList <<|> pure [])) <<|>+        pure (\field -> [field NoSep])+      ) <<|>+    pure []++-- | Makes an unnamed field out of a list of suffixes, a position and a name.+-- This function gets called when we know a field is unnamed and contains an expression that+-- starts with a PrefixExp+-- See the parseField parser where it is used+makeUnNamedField :: Maybe (BinOp, MExpr) -> ExprSuffixList -> (Region, MToken) -> (FieldSep -> Field)+makeUnNamedField Nothing sfs (p, nm) = UnnamedField $ MExpr p $ APrefixExpr $ PFVar nm sfs+makeUnNamedField (Just (op, mexpr)) sfs (p, nm) = UnnamedField $ MExpr p $ (merge (APrefixExpr $ PFVar nm sfs) mexpr)+  where+    -- Merge the first prefixExpr into the expression tree+    merge :: Expr -> MExpr -> Expr+    merge pf e@(MExpr _ (BinOpExpr op' l r)) =  if op > op' then+                                                  BinOpExpr op' (MExpr p $ (merge pf l)) r+                                                else+                                                  BinOpExpr op (MExpr p pf) e+    merge pf e = BinOpExpr op (MExpr p pf) e++-- | A field in a table+parseField :: AParser (FieldSep -> Field)+parseField = ExprField <$ pMTok LSquare <*> parseExpression <* pMTok RSquare <* pMTok Equals <*> parseExpression <<|>+              ((,) <$> pPos' <*> pName <**>+                -- Named field has equals sign immediately after the name+                (((\e (_, n) -> NamedField n e) <$ pMTok Equals <*> parseExpression) <<|>++                -- The lack of equals sign means it's an unnamed field.+                -- The expression of the unnamed field must be starting with a PFVar Prefix expression+                pMany pPFExprSuffix <**>+                  ( makeUnNamedField <$>+                    (+                      -- There are operators, so the expression goes on beyond the prefixExpression+                      curry Just <$> parseBinOp <*> parseExpression <<|>+                      -- There are no operators after the prefix expression+                      pReturn Nothing+                    )+                  )+                )+              ) <<|>+              UnnamedField <$> parseExpression++-- | Field separator+parseFieldSep :: AParser FieldSep+parseFieldSep =+    CommaSep <$ pMTok Comma <<|>+    SemicolonSep <$ pMTok Semicolon
+ src/GLua/TokenTypes.hs view
@@ -0,0 +1,464 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE CPP #-}+{-# LANGUAGE LambdaCase #-}+-- | Contains class instances and functions related to tokens+module GLua.TokenTypes where++import Data.List+import Text.ParserCombinators.UU.BasicInstances+import GLua.AG.Token+import Data.Aeson+import GHC.Generics++instance Show MToken where+    show (MToken _ tok) = show tok++-- | Simple EQ instance. TODO: check for position equality+instance Eq MToken where+    (MToken _ t1) == (MToken _ t2) = t1 == t2++-- | Simple Ord instance. TODO: check for position Ord+instance Ord MToken where+    compare (MToken _ t1) (MToken _ t2) = compare t1 t2++deriving instance Generic MToken++instance ToJSON MToken where+instance FromJSON MToken where++instance Eq LineColPos where+    (LineColPos l c p) == (LineColPos l' c' p') = l == l' && c == c' && p == p'++instance Ord LineColPos where+    compare (LineColPos l c _) (LineColPos l' c' _) =+        compare l l' `mappend` compare c c'++instance ToJSON LineColPos where+    -- this generates a Value+    toJSON (LineColPos line col p) =+        object ["line" .= line, "column" .= col, "pos" .= p]++#if MIN_VERSION_aeson(0,10,0)+    -- this encodes directly to a bytestring Builder+    toEncoding (LineColPos line col p) =+        pairs ("line" .= line <> "column" .= col <> "pos" .= p)+#endif++instance FromJSON LineColPos where+    parseJSON = withObject "LineColPos" $ \v -> LineColPos+            <$> v .: "line"+            <*> v .: "column"+            <*> v .: "pos"++instance Eq Region where+    Region s e == Region s' e' = s == s' && e == e'++instance Ord Region where+    compare (Region s e) (Region s' e') =+        compare s s' `mappend` compare e e'++instance ToJSON Region where+instance FromJSON Region where++instance ToJSON Token where+instance FromJSON Token where++-- | Metatoken algebra+type MTokenAlgebra mtok = Region -> Token -> mtok++mpos :: MToken -> Region+mpos (MToken p _) = p++mtok :: MToken -> Token+mtok (MToken _ t) = t++emptyRg :: Region+emptyRg = Region (LineColPos 0 0 0) (LineColPos 0 0 0)++rgOr :: Region -> Region -> Region+rgOr l r+  | l == emptyRg = r+  | otherwise = l++----------------------------------------+--  Correcting token positions+----------------------------------------+customAdvanceChr :: LineColPos -> Char -> LineColPos+customAdvanceChr (LineColPos line _ abs') '\n' = LineColPos (line + 1) 0 (abs' + 1)+customAdvanceChr (LineColPos line pos' abs') _    = LineColPos line (pos' + 1) (abs' + 1)++customAdvanceStr :: LineColPos -> String -> LineColPos+customAdvanceStr = foldl' customAdvanceChr++customAdvanceToken :: LineColPos -> Token -> LineColPos+customAdvanceToken (LineColPos line pos' abs') t = let len = tokenSize t in LineColPos line (pos' + len) (abs' + len)++-- | Whether the first region ends strictly before the second region starts+before :: Region -> Region -> Bool+before (Region _ (LineColPos _ _ p)) (Region (LineColPos _ _ p') _ ) = p < p'++-- | Whether the first region ends before or on the same line as the second region+beforeOrOnLine :: Region -> Region -> Bool+beforeOrOnLine (Region _ (LineColPos l _ _)) (Region (LineColPos l' _ _) _) = l <= l'++-- | Whether the first region ends before the second region ends+beforeEnd :: Region -> Region -> Bool+beforeEnd (Region _ (LineColPos _ _ p)) (Region _ (LineColPos _ _ p')) = p < p'++-- | Whether the first region ends before or on the same line as the END of the second region+beforeEndLine :: Region -> Region -> Bool+beforeEndLine (Region _ (LineColPos l _ _)) (Region _ (LineColPos l' _ _)) = l <= l'++rgStart :: Region -> LineColPos+rgStart (Region s _) = s++rgEnd :: Region -> LineColPos+rgEnd (Region _ e) = e++-- | Returns a region that starts at the start of the first region+-- and ends BEFORE the start of the second region+upto :: Region -> Region -> Region+upto lr rr = case (rgEnd lr, rgStart rr) of+    (_, LineColPos 0 0 0) -> lr+    (LineColPos l c _, LineColPos l' c' _)+        | l' > l || (l' == l && c' > c) -> lr+        | otherwise -> Region (rgStart lr) (rgStart rr)++-- | Fold over metatoken+foldMToken :: MTokenAlgebra t -> MToken -> t+foldMToken alg (MToken p t) = alg p t++-- | mFold: Apply a TokenAlgebra to an MToken+mFold :: TokenAlgebra a -> MToken -> a+mFold alg = foldMToken f+  where+    f _ = foldToken alg++-- | Huge token algebra+type TokenAlgebra token = (+    ( -- Comments and whitespace+        String -> token,+        String -> token,    -- DashComment+        Int -> String -> token,    -- DashBlockComment+        String -> token,    -- SlashComment+        String -> token,    -- SlashBlockComment+        token               -- Semicolon+    ),+    ( -- Constants+        String -> token,    -- TNumber+        String -> token,    -- DQString+        String -> token,    -- SQString+        String -> token,    -- MLString+        token,              -- TTrue+        token,              -- TFalse+        token,              -- Nil+        token               -- VarArg+    ), -- operators+    (+        token,              -- Plus+        token,              -- Minus+        token,              -- Multiply+        token,              -- Divide+        token,              -- Modulus+        token,              -- Power+        token,              -- TEq+        token,              -- TNEq+        token,              -- TCNEq+        token,              -- TLEQ+        token,              -- TGEQ+        token,              -- TLT+        token,              -- TGT+        token,              -- Equals+        token,              -- Concatenate+        token,              -- Colon+        token,              -- Dot+        token,              -- Comma+        token,              -- Hash+        token,              -- Not+        token,              -- CNot+        token,              -- And+        token,              -- CAnd+        token,              -- Or+        token               -- COr+    ),+    ( -- Keywords+        token,              -- Function+        token,              -- Local+        token,              -- If+        token,              -- Then+        token,              -- Elseif+        token,              -- Else+        token,              -- For+        token,              -- In+        token,              -- Do+        token,              -- While+        token,              -- Until+        token,              -- Repeat+        token,              -- Continue+        token,              -- Break+        token,              -- Return+        token               -- End+    ),+    ( -- Brackets+        token,              -- LRound+        token,              -- RRound+        token,              -- LCurly+        token,              -- RCurly+        token,              -- LSquare+        token               -- RSquare+    ),+    ( -- Other+        String -> token,    -- Label+        String -> token     -- Identifier+    )+    )++-- | Fold over token definition+foldToken :: TokenAlgebra t -> Token -> t+foldToken ((tWhitespace, tDashComment, tDashBlockComment, tSlashComment, tSlashBlockComment, tSemicolon), (tTNumber, tDQString, tSQString, tMLString, tTTrue, tTFalse, tNil, tVarArg), (tPlus, tMinus, tMultiply, tDivide, tModulus, tPower, tTEq, tTNEq, tTCNEq, tTLEQ, tTGEQ, tTLT, tTGT, tEquals, tConcatenate, tColon, tDot, tComma, tHash, tNot, tCNot, tAnd, tCAnd, tOr, tCOr), (tFunction, tLocal, tIf, tThen, tElseif, tElse, tFor, tIn, tDo, tWhile, tUntil, tRepeat, tContinue, tBreak, tReturn, tEnd), (tLRound, tRRound, tLCurly, tRCurly, tLSquare, tRSquare), (tLabel, tIdentifier)) = fold+    where+        fold (Whitespace str) = tWhitespace str+        fold (DashComment str) = tDashComment str+        fold (DashBlockComment depth str) = tDashBlockComment depth str+        fold (SlashComment str) = tSlashComment str+        fold (SlashBlockComment str) = tSlashBlockComment str+        fold (TNumber str) = tTNumber str+        fold (Label str) = tLabel str+        fold (Identifier str) = tIdentifier str+        fold (DQString str) = tDQString str+        fold (SQString str) = tSQString str+        fold (MLString str) = tMLString str+        fold And = tAnd+        fold CAnd = tCAnd+        fold Break = tBreak+        fold Do = tDo+        fold Else = tElse+        fold Elseif = tElseif+        fold End = tEnd+        fold TFalse = tTFalse+        fold For = tFor+        fold Function = tFunction+        fold If = tIf+        fold In = tIn+        fold Local = tLocal+        fold Nil = tNil+        fold Not = tNot+        fold CNot = tCNot+        fold Or = tOr+        fold COr = tCOr+        fold Repeat = tRepeat+        fold Continue = tContinue+        fold Return = tReturn+        fold Then = tThen+        fold TTrue = tTTrue+        fold Until = tUntil+        fold While = tWhile+        fold Plus = tPlus+        fold Minus = tMinus+        fold Multiply = tMultiply+        fold Divide = tDivide+        fold Modulus = tModulus+        fold Power = tPower+        fold Hash = tHash+        fold TEq = tTEq+        fold TNEq = tTNEq+        fold TCNEq = tTCNEq+        fold TLEQ = tTLEQ+        fold TGEQ = tTGEQ+        fold TLT = tTLT+        fold TGT = tTGT+        fold Equals = tEquals+        fold LRound = tLRound+        fold RRound = tRRound+        fold LCurly = tLCurly+        fold RCurly = tRCurly+        fold LSquare = tLSquare+        fold RSquare = tRSquare+        fold Semicolon = tSemicolon+        fold Colon = tColon+        fold Comma = tComma+        fold Dot = tDot+        fold Concatenate = tConcatenate+        fold VarArg = tVarArg++-- | Simple show instance+instance Show Token where+    show = foldToken ((+        id,+        ("--" ++), -- DashComment+        \d s -> let n = replicate d '=' in "--[" ++ n ++ '[' : s ++ ']' : n ++ "]", -- DashBlockComment+        ("//" ++), -- SlashComment+        \s -> "/*" ++ s ++ "*/", -- SlashBlockComment+        ";" -- Semicolon+        ),+        (+        id, -- TNumber+        \s -> "\"" ++ s ++ "\"", -- DQString+        \s -> "'" ++ s ++ "'", -- SQString+        id, -- MLString+        "true", -- TTrue+        "false", -- TFalse+        "nil", -- Nil+        "..." -- VarArg+        ),+        (+        "+", -- Plus+        "-", -- Minus+        "*", -- Multiply+        "/", -- Divide+        "%", -- Modulus+        "^", -- Power+        "==", -- TEq+        "~=", -- TNEq+        "!=", -- TCNEq+        "<=", -- TLEQ+        ">=", -- TGEQ+        "<", -- TLT+        ">", -- TGT+        "=", -- Equals+        "..", -- Concatenate+        ":", -- Colon+        ".", -- Dot+        ",", -- Comma+        "#", -- Hash+        "not", -- Not+        "!", -- CNot+        "and", -- And+        "&&", -- CAnd+        "or", -- Or+        "||" -- COr+        ),+        (+        "function", -- Function+        "local", -- Local+        "if", -- If+        "then", -- Then+        "elseif", -- Elseif+        "else", -- Else+        "for", -- For+        "in", -- In+        "do", -- Do+        "while", -- While+        "until", -- Until+        "repeat", -- Repeat+        "continue", -- Continue+        "break", -- Break+        "return", -- Return+        "end" -- End+        ),+        (+        "(", -- LRound+        ")", -- RRound+        "{", -- LCurly+        "}", -- RCurly+        "[", -- LSquare+        "]" -- RSquare+        ),+        (+        id, -- Label+        id -- Identifier+        )+        )++-- | Whether an mtoken is a comment+isWhitespace :: MToken -> Bool+isWhitespace = mFold ((const True,const False,\_ _ -> False,const False,const False,False),(const False,const False,const False,const False,False,False,False,False),(False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False),(False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False),(False,False,False,False,False,False),(const False,const False))++-- | Whether an mtoken is a comment+isComment :: MToken -> Bool+isComment = mFold ((const False,const True,\_ _ -> True,const True,const True,False),(const False,const False,const False,const False,False,False,False,False),(False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False),(False,False,False,False,False,False,False,False,False,False,False,False,False,False,False,False),(False,False,False,False,False,False),(const False,const False))++-- | Split the tokens by comments and other tokens+splitComments :: [MToken] -> ([MToken], [MToken])+splitComments = partition isComment++tokenLabel :: MToken -> String+tokenLabel = mFold ((const "", const "",\_ _ -> "",const "",const "",""),(const "",const "",const "",const "","","","",""),("","","","","","","","","","","","","","","","","","","","","","","","",""),("","","","","","","","","","","","","","","",""),("","","","","",""),(id, id))++-- | The size of a token in characters+tokenSize :: Token -> Int+tokenSize = foldToken ((+    length, -- whitespace+    (+2) . length, -- DashComment+    \d s -> 6 + length s + 2 * d, -- DashBlockComment+    (+2) . length, -- SlashComment+    (+4) . length, -- SlashBlockComment+    1 -- Semicolon+    ),+    (+    length, -- TNumber+    (+2) . length, -- DQString+    (+2) . length, -- SQString+    length, -- MLString+    4, -- TTrue+    5, -- TFalse+    3, -- Nil+    3 -- VarArg+    ),+    (+    1, -- Plus+    1, -- Minus+    1, -- Multiply+    1, -- Divide+    1, -- Modulus+    1, -- Power+    2, -- TEq+    2, -- TNEq+    2, -- TCNEq+    2, -- TLEQ+    2, -- TGEQ+    1, -- TLT+    1, -- TGT+    1, -- Equals+    2, -- Concatenate+    1, -- Colon+    1, -- Dot+    1, -- Comma+    1, -- Hash+    3, -- Not+    1, -- CNot+    3, -- And+    2, -- CAnd+    2, -- Or+    2 -- COr+    ),+    (+    8, -- Function+    5, -- Local+    2, -- If+    4, -- Then+    6, -- Elseif+    4, -- Else+    3, -- For+    2, -- In+    2, -- Do+    5, -- While+    5, -- Until+    6, -- Repeat+    8, -- Continue+    5, -- Break+    6, -- Return+    3 -- End+    ),+    (+    1, -- LRound+    1, -- RRound+    1, -- LCurly+    1, -- RCurly+    1, -- LSquare+    1 -- RSquare+    ),+    (+    (+2) . length, -- Label+    length -- Identifier+    )+    )++isSingleLineComment :: Token -> Bool+isSingleLineComment = \case+    DashComment _ -> True+    SlashComment _ -> True+    _ -> False
+ src/GLuaFixer/AG/ASTLint.hs view
@@ -0,0 +1,14263 @@+++{-# LANGUAGE DeriveGeneric #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}++{-# LANGUAGE DeriveGeneric #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}++{-# OPTIONS_GHC -fno-warn-unused-binds #-}+{-# LANGUAGE LambdaCase #-}+-- UUAGC 0.9.53.1 (src/GLuaFixer/AG/ASTLint.ag)+module GLuaFixer.AG.ASTLint where++{-# LINE 9 "src/GLuaFixer/AG/../../GLua/AG/Token.ag" #-}++import Text.ParserCombinators.UU.BasicInstances hiding (pos)+import GHC.Generics+{-# LINE 19 "src/GLuaFixer/AG/ASTLint.hs" #-}++{-# LINE 10 "src/GLuaFixer/AG/../../GLua/AG/AST.ag" #-}++import GLua.AG.Token+import GLua.TokenTypes ()+import GHC.Generics+import Data.Aeson+{-# LINE 27 "src/GLuaFixer/AG/ASTLint.hs" #-}++{-# LINE 10 "src/GLuaFixer/AG/ASTLint.ag" #-}++import GLua.AG.AST+import qualified GLua.AG.PrettyPrint as PP+import qualified GLua.AG.Token as T+import GLua.TokenTypes+import qualified Data.Set as S+import qualified Data.Map.Strict as M+import Data.Char (isLower, isUpper)+import Data.Maybe+import GLuaFixer.LintMessage+import GLuaFixer.LintSettings+{-# LINE 41 "src/GLuaFixer/AG/ASTLint.hs" #-}+{-# LINE 28 "src/GLuaFixer/AG/ASTLint.ag" #-}++warn :: Region -> Issue -> FilePath -> LintMessage+warn pos issue = LintMessage LintWarning pos issue++-- Used in detecting "not (a == b)" kind of things+oppositeBinOp :: BinOp -> Maybe String+oppositeBinOp ALT = Just ">="+oppositeBinOp AGT = Just "<="+oppositeBinOp ALEQ = Just ">"+oppositeBinOp AGEQ = Just "<"+oppositeBinOp ANEq = Just "=="+oppositeBinOp AEq = Just "~="+oppositeBinOp _ = Nothing++-- Checks whether a variable shadows existing variables+checkShadows :: [M.Map String (Bool, Region)] -> MToken -> Maybe (FilePath -> LintMessage)+checkShadows [] _ = Nothing+checkShadows _ (MToken _ (Identifier "_")) = Nothing -- Exception for vars named '_'+checkShadows (scope : scs) mtok' =+    if M.member lbl scope then+      Just $ warn (mpos mtok') $ VariableShadows lbl location+    else+      checkShadows scs mtok'+    where+        lbl = tokenLabel mtok'+        location = snd $ fromMaybe (error "checkShadows fromMaybe") $ M.lookup lbl scope++-- Determines whether a variable is local+-- It is local if it does not exist in any but the topmost (global) scope+-- it may or may not exist in the topmost scope.+isVariableLocal :: [M.Map String (Bool, Region)] -> String -> Bool+isVariableLocal [] _ = False+isVariableLocal [_] _ = False+isVariableLocal (scope : scs) var =+    case M.lookup var scope of+        Just _ -> True+        Nothing -> isVariableLocal scs var+++-- Registers a variable as global variable when it hasn't been+-- introduced in any of the visible scopes+registerVariable :: [M.Map String (Bool, Region)] -> Region -> String -> Bool -> [M.Map String (Bool, Region)]+registerVariable [] _ _ _ = error "cannot register top level variable"+registerVariable (scope : []) pos var used =+    [ case M.lookup var scope of+        Just (used', pos') -> M.insert var (used || used', pos') scope+        Nothing -> M.insert var (used, pos) scope+    ] -- global scope+registerVariable (scope : scs) pos var used = case M.lookup var scope of+                                                Just (True, _) -> scope : scs+                                                Just (False, pos') -> M.insert var (used, pos') scope : scs+                                                Nothing -> scope : registerVariable scs pos var used++findSelf :: [MToken] -> Bool+findSelf ((MToken _ (Identifier "self")) : _) = True+findSelf _ = False++data VariableStyle+   = StartsLowerCase+   | StartsUpperCase+   | VariableStyleNeither+   deriving (Eq)++data DeterminedVariableStyle+   = VarStyleNotDetermined+   | VarStyleDetermined !VariableStyle++combineDeterminedVarStyle :: DeterminedVariableStyle -> VariableStyle -> DeterminedVariableStyle+combineDeterminedVarStyle old new = case old of+    VarStyleNotDetermined -> VarStyleDetermined new+    VarStyleDetermined VariableStyleNeither -> VarStyleDetermined new+    _ -> old++determineVariableStyle :: String -> VariableStyle+determineVariableStyle = \case+    [] -> VariableStyleNeither+    (c : _)+        | isLower c -> StartsLowerCase+        | isUpper c -> StartsUpperCase+        | otherwise -> VariableStyleNeither++variableStyleInconsistent :: DeterminedVariableStyle -> VariableStyle -> Bool+variableStyleInconsistent determinedStyle varStyle = case determinedStyle of+    VarStyleNotDetermined -> False+    VarStyleDetermined VariableStyleNeither -> False+    VarStyleDetermined existing -> case varStyle of+        VariableStyleNeither -> False+        _ -> existing /= varStyle++unknownIdentifier :: String+unknownIdentifier = "Unknown identifier"++{-# LINE 135 "src/GLuaFixer/AG/ASTLint.hs" #-}++{-# LINE 647 "src/GLuaFixer/AG/ASTLint.ag" #-}++inh_AST :: LintSettings -> Inh_AST+inh_AST conf = Inh_AST {+                config_Inh_AST                  = conf,+                isMeta_Inh_AST                  = False,+                loopLevel_Inh_AST               = 0,+                globalDefinitions_Inh_AST       = M.empty,+                mtokenPos_Inh_AST               = emptyRg,+                scopeLevel_Inh_AST              = 0,+                scopes_Inh_AST                  = [M.empty],+                funcName_Inh_AST                = "",+                isInModule_Inh_AST              = False,+                variableStyle_Inh_AST           = VarStyleNotDetermined+               }++allAttributes :: LintSettings -> AST -> Syn_AST+allAttributes conf p = wrap_AST (sem_AST p) (inh_AST conf)++astWarnings :: LintSettings -> AST -> [String -> LintMessage]+astWarnings conf p = warnings_Syn_AST $ allAttributes conf p++globalDefinitions :: LintSettings -> AST -> M.Map String [Region]+globalDefinitions conf p = globalDefinitions_Syn_AST $ allAttributes conf p+{-# LINE 161 "src/GLuaFixer/AG/ASTLint.hs" #-}+-- AReturn -----------------------------------------------------+-- cata+sem_AReturn :: AReturn ->+               T_AReturn+sem_AReturn (AReturn _pos _values) =+    (sem_AReturn_AReturn (sem_Region _pos) (sem_MExprList _values))+sem_AReturn (NoReturn) =+    (sem_AReturn_NoReturn)+-- semantic domain+type T_AReturn = ( AReturn,T_AReturn_1)+type T_AReturn_1 = LintSettings ->+                   String ->+                   (M.Map String [Region]) ->+                   Bool ->+                   Bool ->+                   Int ->+                   Region ->+                   Int ->+                   ([M.Map String (Bool, Region)]) ->+                   DeterminedVariableStyle ->+                   ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),Int,DeterminedVariableStyle,([String -> LintMessage]))+data Inh_AReturn = Inh_AReturn {config_Inh_AReturn :: LintSettings,funcName_Inh_AReturn :: String,globalDefinitions_Inh_AReturn :: (M.Map String [Region]),isInModule_Inh_AReturn :: Bool,isMeta_Inh_AReturn :: Bool,loopLevel_Inh_AReturn :: Int,mtokenPos_Inh_AReturn :: Region,scopeLevel_Inh_AReturn :: Int,scopes_Inh_AReturn :: ([M.Map String (Bool, Region)]),variableStyle_Inh_AReturn :: DeterminedVariableStyle}+data Syn_AReturn = Syn_AReturn {copy_Syn_AReturn :: AReturn,globalDefinitions_Syn_AReturn :: (M.Map String [Region]),identifier_Syn_AReturn :: String,isInModule_Syn_AReturn :: Bool,mtokenPos_Syn_AReturn :: Region,scopes_Syn_AReturn :: ([M.Map String (Bool, Region)]),statementCount_Syn_AReturn :: Int,variableStyle_Syn_AReturn :: DeterminedVariableStyle,warnings_Syn_AReturn :: ([String -> LintMessage])}+wrap_AReturn :: T_AReturn ->+                Inh_AReturn ->+                Syn_AReturn+wrap_AReturn sem (Inh_AReturn _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_AReturn _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOstatementCount _lhsOvariableStyle _lhsOwarnings))+sem_AReturn_AReturn :: T_Region ->+                       T_MExprList ->+                       T_AReturn+sem_AReturn_AReturn pos_ values_ =+    (case (values_) of+     { ( _valuesIcopy,values_1) ->+         (case (pos_) of+          { ( _posIcopy,_posIidentifier,_posIwarnings) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      AReturn _posIcopy _valuesIcopy+                      {-# LINE 202 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 207 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_AReturn_AReturn_1 :: T_AReturn_1+                            sem_AReturn_AReturn_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 224 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _valuesOscopes ->+                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisMeta+                                              {-# LINE 229 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _valuesOisMeta ->+                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIisInModule+                                               {-# LINE 234 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _valuesOisInModule ->+                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIglobalDefinitions+                                                {-# LINE 239 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _valuesOglobalDefinitions ->+                                         (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIconfig+                                                 {-# LINE 244 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _valuesOconfig ->+                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIvariableStyle+                                                  {-# LINE 249 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _valuesOvariableStyle ->+                                           (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIscopeLevel+                                                   {-# LINE 254 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _valuesOscopeLevel ->+                                            (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsImtokenPos+                                                    {-# LINE 259 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _valuesOmtokenPos ->+                                             (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIloopLevel+                                                     {-# LINE 264 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _valuesOloopLevel ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 269 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _valuesOfuncName ->+                                               (case (({-# LINE 492 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       True+                                                       {-# LINE 274 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _valuesOtopLevel ->+                                                (case (({-# LINE 491 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        True+                                                        {-# LINE 279 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _valuesOinParentheses ->+                                                 (case (values_1 _valuesOconfig _valuesOfuncName _valuesOglobalDefinitions _valuesOinParentheses _valuesOisInModule _valuesOisMeta _valuesOloopLevel _valuesOmtokenPos _valuesOscopeLevel _valuesOscopes _valuesOtopLevel _valuesOvariableStyle) of+                                                  { ( _valuesIglobalDefinitions,_valuesIidentifier,_valuesIisInModule,_valuesImtokenPos,_valuesIscopes,_valuesIvariableStyle,_valuesIwarnings) ->+                                                      (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _valuesIglobalDefinitions+                                                              {-# LINE 286 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOglobalDefinitions ->+                                                       (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               (const _posIidentifier _valuesIidentifier)+                                                               {-# LINE 291 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOidentifier ->+                                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _valuesIisInModule+                                                                {-# LINE 296 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOisInModule ->+                                                         (case (({-# LINE 493 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _posIcopy+                                                                 {-# LINE 301 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOmtokenPos ->+                                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _valuesIscopes+                                                                  {-# LINE 306 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOscopes ->+                                                           (case (({-# LINE 157 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   1+                                                                   {-# LINE 311 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _lhsOstatementCount ->+                                                            (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _valuesIvariableStyle+                                                                    {-# LINE 316 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _lhsOvariableStyle ->+                                                             (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _posIwarnings ++ _valuesIwarnings+                                                                     {-# LINE 321 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _lhsOwarnings ->+                                                              ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_AReturn_AReturn_1)) of+                 { ( sem_AReturn_1) ->+                 ( _lhsOcopy,sem_AReturn_1) }) }) }) }) })+sem_AReturn_NoReturn :: T_AReturn+sem_AReturn_NoReturn =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            NoReturn+            {-# LINE 332 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 337 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_AReturn_NoReturn_1 :: T_AReturn_1+                  sem_AReturn_NoReturn_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 354 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 359 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 364 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 369 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 374 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 495 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        0+                                        {-# LINE 379 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOstatementCount ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 384 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 389 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_AReturn_NoReturn_1)) of+       { ( sem_AReturn_1) ->+       ( _lhsOcopy,sem_AReturn_1) }) }) })+-- AST ---------------------------------------------------------+-- cata+sem_AST :: AST ->+           T_AST+sem_AST (AST _comments _chunk) =+    (sem_AST_AST _comments (sem_Block _chunk))+-- semantic domain+type T_AST = LintSettings ->+             String ->+             (M.Map String [Region]) ->+             Bool ->+             Bool ->+             Int ->+             Region ->+             Int ->+             ([M.Map String (Bool, Region)]) ->+             DeterminedVariableStyle ->+             ( AST,(M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_AST = Inh_AST {config_Inh_AST :: LintSettings,funcName_Inh_AST :: String,globalDefinitions_Inh_AST :: (M.Map String [Region]),isInModule_Inh_AST :: Bool,isMeta_Inh_AST :: Bool,loopLevel_Inh_AST :: Int,mtokenPos_Inh_AST :: Region,scopeLevel_Inh_AST :: Int,scopes_Inh_AST :: ([M.Map String (Bool, Region)]),variableStyle_Inh_AST :: DeterminedVariableStyle}+data Syn_AST = Syn_AST {copy_Syn_AST :: AST,globalDefinitions_Syn_AST :: (M.Map String [Region]),identifier_Syn_AST :: String,isInModule_Syn_AST :: Bool,mtokenPos_Syn_AST :: Region,scopes_Syn_AST :: ([M.Map String (Bool, Region)]),variableStyle_Syn_AST :: DeterminedVariableStyle,warnings_Syn_AST :: ([String -> LintMessage])}+wrap_AST :: T_AST ->+            Inh_AST ->+            Syn_AST+wrap_AST sem (Inh_AST _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_AST _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_AST_AST :: ([MToken]) ->+               T_Block ->+               T_AST+sem_AST_AST comments_ chunk_ =+    (\ _lhsIconfig+       _lhsIfuncName+       _lhsIglobalDefinitions+       _lhsIisInModule+       _lhsIisMeta+       _lhsIloopLevel+       _lhsImtokenPos+       _lhsIscopeLevel+       _lhsIscopes+       _lhsIvariableStyle ->+         (case (chunk_) of+          { ( _chunkIcopy,chunk_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      AST comments_ _chunkIcopy+                      {-# LINE 440 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 445 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                        _lhsIisMeta+                        {-# LINE 450 "src/GLuaFixer/AG/ASTLint.hs" #-}+                        )) of+                 { _chunkOisMeta ->+                 (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                         _lhsIisInModule+                         {-# LINE 455 "src/GLuaFixer/AG/ASTLint.hs" #-}+                         )) of+                  { _chunkOisInModule ->+                  (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                          _lhsIglobalDefinitions+                          {-# LINE 460 "src/GLuaFixer/AG/ASTLint.hs" #-}+                          )) of+                   { _chunkOglobalDefinitions ->+                   (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                           _lhsIconfig+                           {-# LINE 465 "src/GLuaFixer/AG/ASTLint.hs" #-}+                           )) of+                    { _chunkOconfig ->+                    (case (({-# LINE 292 "src/GLuaFixer/AG/ASTLint.ag" #-}+                            M.empty : _lhsIscopes+                            {-# LINE 470 "src/GLuaFixer/AG/ASTLint.hs" #-}+                            )) of+                     { _chunkOscopes ->+                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                             _lhsIvariableStyle+                             {-# LINE 475 "src/GLuaFixer/AG/ASTLint.hs" #-}+                             )) of+                      { _chunkOvariableStyle ->+                      (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                              _lhsIscopeLevel+                              {-# LINE 480 "src/GLuaFixer/AG/ASTLint.hs" #-}+                              )) of+                       { _chunkOscopeLevel ->+                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                               _lhsImtokenPos+                               {-# LINE 485 "src/GLuaFixer/AG/ASTLint.hs" #-}+                               )) of+                        { _chunkOmtokenPos ->+                        (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                _lhsIloopLevel+                                {-# LINE 490 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                )) of+                         { _chunkOloopLevel ->+                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                 _lhsIfuncName+                                 {-# LINE 495 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                 )) of+                          { _chunkOfuncName ->+                          (case (({-# LINE 293 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                  False+                                  {-# LINE 500 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                  )) of+                           { _chunkOisRepeat ->+                           (case (chunk_1 _chunkOconfig _chunkOfuncName _chunkOglobalDefinitions _chunkOisInModule _chunkOisMeta _chunkOisRepeat _chunkOloopLevel _chunkOmtokenPos _chunkOscopeLevel _chunkOscopes _chunkOvariableStyle) of+                            { ( _chunkIglobalDefinitions,_chunkIidentifier,_chunkIisIfStatement,_chunkIisInModule,_chunkImtokenPos,_chunkIscopes,_chunkIstatementCount,_chunkIvariableStyle,_chunkIwarnings) ->+                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _chunkIglobalDefinitions+                                        {-# LINE 507 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOglobalDefinitions ->+                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _chunkIidentifier+                                         {-# LINE 512 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOidentifier ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _chunkIisInModule+                                          {-# LINE 517 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOisInModule ->+                                   (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _chunkImtokenPos+                                           {-# LINE 522 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lhsOmtokenPos ->+                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _chunkIscopes+                                            {-# LINE 527 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _lhsOscopes ->+                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _chunkIvariableStyle+                                             {-# LINE 532 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _lhsOvariableStyle ->+                                      (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _chunkIwarnings+                                              {-# LINE 537 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _lhsOwarnings ->+                                       ( _lhsOcopy,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+-- Args --------------------------------------------------------+-- cata+sem_Args :: Args ->+            T_Args+sem_Args (ListArgs _args) =+    (sem_Args_ListArgs (sem_MExprList _args))+sem_Args (TableArg _arg) =+    (sem_Args_TableArg (sem_FieldList _arg))+sem_Args (StringArg _arg) =+    (sem_Args_StringArg (sem_MToken _arg))+-- semantic domain+type T_Args = ( Args,T_Args_1)+type T_Args_1 = LintSettings ->+                String ->+                (M.Map String [Region]) ->+                Bool ->+                Bool ->+                Int ->+                Region ->+                Int ->+                ([M.Map String (Bool, Region)]) ->+                DeterminedVariableStyle ->+                ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_Args = Inh_Args {config_Inh_Args :: LintSettings,funcName_Inh_Args :: String,globalDefinitions_Inh_Args :: (M.Map String [Region]),isInModule_Inh_Args :: Bool,isMeta_Inh_Args :: Bool,loopLevel_Inh_Args :: Int,mtokenPos_Inh_Args :: Region,scopeLevel_Inh_Args :: Int,scopes_Inh_Args :: ([M.Map String (Bool, Region)]),variableStyle_Inh_Args :: DeterminedVariableStyle}+data Syn_Args = Syn_Args {copy_Syn_Args :: Args,globalDefinitions_Syn_Args :: (M.Map String [Region]),identifier_Syn_Args :: String,isInModule_Syn_Args :: Bool,mtokenPos_Syn_Args :: Region,scopes_Syn_Args :: ([M.Map String (Bool, Region)]),variableStyle_Syn_Args :: DeterminedVariableStyle,warnings_Syn_Args :: ([String -> LintMessage])}+wrap_Args :: T_Args ->+             Inh_Args ->+             Syn_Args+wrap_Args sem (Inh_Args _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_Args _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_Args_ListArgs :: T_MExprList ->+                     T_Args+sem_Args_ListArgs args_ =+    (case (args_) of+     { ( _argsIcopy,args_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 ListArgs _argsIcopy+                 {-# LINE 580 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 585 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Args_ListArgs_1 :: T_Args_1+                       sem_Args_ListArgs_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 602 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _argsOscopes ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 607 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _argsOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 612 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _argsOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 617 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _argsOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 622 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _argsOconfig ->+                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIvariableStyle+                                             {-# LINE 627 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _argsOvariableStyle ->+                                      (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIscopeLevel+                                              {-# LINE 632 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _argsOscopeLevel ->+                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsImtokenPos+                                               {-# LINE 637 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _argsOmtokenPos ->+                                        (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIloopLevel+                                                {-# LINE 642 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _argsOloopLevel ->+                                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIfuncName+                                                 {-# LINE 647 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _argsOfuncName ->+                                          (case (({-# LINE 606 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  True+                                                  {-# LINE 652 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _argsOtopLevel ->+                                           (case (({-# LINE 605 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   True+                                                   {-# LINE 657 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _argsOinParentheses ->+                                            (case (args_1 _argsOconfig _argsOfuncName _argsOglobalDefinitions _argsOinParentheses _argsOisInModule _argsOisMeta _argsOloopLevel _argsOmtokenPos _argsOscopeLevel _argsOscopes _argsOtopLevel _argsOvariableStyle) of+                                             { ( _argsIglobalDefinitions,_argsIidentifier,_argsIisInModule,_argsImtokenPos,_argsIscopes,_argsIvariableStyle,_argsIwarnings) ->+                                                 (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _argsIglobalDefinitions+                                                         {-# LINE 664 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOglobalDefinitions ->+                                                  (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _argsIidentifier+                                                          {-# LINE 669 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOidentifier ->+                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _argsIisInModule+                                                           {-# LINE 674 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOisInModule ->+                                                    (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _argsImtokenPos+                                                            {-# LINE 679 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOmtokenPos ->+                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _argsIscopes+                                                             {-# LINE 684 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOscopes ->+                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _argsIvariableStyle+                                                              {-# LINE 689 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOvariableStyle ->+                                                       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _argsIwarnings+                                                               {-# LINE 694 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOwarnings ->+                                                        ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Args_ListArgs_1)) of+            { ( sem_Args_1) ->+            ( _lhsOcopy,sem_Args_1) }) }) }) })+sem_Args_TableArg :: T_FieldList ->+                     T_Args+sem_Args_TableArg arg_ =+    (case (arg_) of+     { ( _argIcopy,arg_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 TableArg _argIcopy+                 {-# LINE 708 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 713 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Args_TableArg_1 :: T_Args_1+                       sem_Args_TableArg_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 730 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _argOscopes ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 735 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _argOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 740 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _argOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 745 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _argOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 750 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _argOconfig ->+                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIvariableStyle+                                             {-# LINE 755 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _argOvariableStyle ->+                                      (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIscopeLevel+                                              {-# LINE 760 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _argOscopeLevel ->+                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsImtokenPos+                                               {-# LINE 765 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _argOmtokenPos ->+                                        (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIloopLevel+                                                {-# LINE 770 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _argOloopLevel ->+                                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIfuncName+                                                 {-# LINE 775 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _argOfuncName ->+                                          (case (({-# LINE 608 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  S.empty+                                                  {-# LINE 780 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _argOfieldNames ->+                                           (case (arg_1 _argOconfig _argOfieldNames _argOfuncName _argOglobalDefinitions _argOisInModule _argOisMeta _argOloopLevel _argOmtokenPos _argOscopeLevel _argOscopes _argOvariableStyle) of+                                            { ( _argIfieldNames,_argIglobalDefinitions,_argIidentifier,_argIisInModule,_argImtokenPos,_argIscopes,_argIvariableStyle,_argIwarnings) ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _argIglobalDefinitions+                                                        {-# LINE 787 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOglobalDefinitions ->+                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _argIidentifier+                                                         {-# LINE 792 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOidentifier ->+                                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _argIisInModule+                                                          {-# LINE 797 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOisInModule ->+                                                   (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _argImtokenPos+                                                           {-# LINE 802 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOmtokenPos ->+                                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _argIscopes+                                                            {-# LINE 807 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOscopes ->+                                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _argIvariableStyle+                                                             {-# LINE 812 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOvariableStyle ->+                                                      (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _argIwarnings+                                                              {-# LINE 817 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOwarnings ->+                                                       ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Args_TableArg_1)) of+            { ( sem_Args_1) ->+            ( _lhsOcopy,sem_Args_1) }) }) }) })+sem_Args_StringArg :: T_MToken ->+                      T_Args+sem_Args_StringArg arg_ =+    (case (arg_) of+     { ( _argIcopy,_argImtok,_argImtokenPos,arg_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 StringArg _argIcopy+                 {-# LINE 831 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 836 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Args_StringArg_1 :: T_Args_1+                       sem_Args_StringArg_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIglobalDefinitions+                                        {-# LINE 853 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _argOglobalDefinitions ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 858 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _argOscopes ->+                                  (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsImtokenPos+                                          {-# LINE 863 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _argOmtokenPos ->+                                   (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIisMeta+                                           {-# LINE 868 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _argOisMeta ->+                                    (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIisInModule+                                            {-# LINE 873 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _argOisInModule ->+                                     (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIfuncName+                                             {-# LINE 878 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _argOfuncName ->+                                      (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIconfig+                                              {-# LINE 883 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _argOconfig ->+                                       (case (arg_1 _argOconfig _argOfuncName _argOglobalDefinitions _argOisInModule _argOisMeta _argOmtokenPos _argOscopes) of+                                        { ( _argIglobalDefinitions,_argIidentifier,_argIisInModule,_argIscopes,_argIwarnings) ->+                                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _argIglobalDefinitions+                                                    {-# LINE 890 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _lhsOglobalDefinitions ->+                                             (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _argIidentifier+                                                     {-# LINE 895 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _lhsOidentifier ->+                                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _argIisInModule+                                                      {-# LINE 900 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _lhsOisInModule ->+                                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _argImtokenPos+                                                       {-# LINE 905 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _lhsOmtokenPos ->+                                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _argIscopes+                                                        {-# LINE 910 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOscopes ->+                                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsIvariableStyle+                                                         {-# LINE 915 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOvariableStyle ->+                                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _argIwarnings+                                                          {-# LINE 920 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOwarnings ->+                                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Args_StringArg_1)) of+            { ( sem_Args_1) ->+            ( _lhsOcopy,sem_Args_1) }) }) }) })+-- BinOp -------------------------------------------------------+-- cata+sem_BinOp :: BinOp ->+             T_BinOp+sem_BinOp (AOr) =+    (sem_BinOp_AOr)+sem_BinOp (AAnd) =+    (sem_BinOp_AAnd)+sem_BinOp (ALT) =+    (sem_BinOp_ALT)+sem_BinOp (AGT) =+    (sem_BinOp_AGT)+sem_BinOp (ALEQ) =+    (sem_BinOp_ALEQ)+sem_BinOp (AGEQ) =+    (sem_BinOp_AGEQ)+sem_BinOp (ANEq) =+    (sem_BinOp_ANEq)+sem_BinOp (AEq) =+    (sem_BinOp_AEq)+sem_BinOp (AConcatenate) =+    (sem_BinOp_AConcatenate)+sem_BinOp (APlus) =+    (sem_BinOp_APlus)+sem_BinOp (BinMinus) =+    (sem_BinOp_BinMinus)+sem_BinOp (AMultiply) =+    (sem_BinOp_AMultiply)+sem_BinOp (ADivide) =+    (sem_BinOp_ADivide)+sem_BinOp (AModulus) =+    (sem_BinOp_AModulus)+sem_BinOp (APower) =+    (sem_BinOp_APower)+-- semantic domain+type T_BinOp = ( BinOp,T_BinOp_1)+type T_BinOp_1 = LintSettings ->+                 String ->+                 (M.Map String [Region]) ->+                 Bool ->+                 Bool ->+                 Int ->+                 Region ->+                 Int ->+                 ([M.Map String (Bool, Region)]) ->+                 DeterminedVariableStyle ->+                 ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_BinOp = Inh_BinOp {config_Inh_BinOp :: LintSettings,funcName_Inh_BinOp :: String,globalDefinitions_Inh_BinOp :: (M.Map String [Region]),isInModule_Inh_BinOp :: Bool,isMeta_Inh_BinOp :: Bool,loopLevel_Inh_BinOp :: Int,mtokenPos_Inh_BinOp :: Region,scopeLevel_Inh_BinOp :: Int,scopes_Inh_BinOp :: ([M.Map String (Bool, Region)]),variableStyle_Inh_BinOp :: DeterminedVariableStyle}+data Syn_BinOp = Syn_BinOp {copy_Syn_BinOp :: BinOp,globalDefinitions_Syn_BinOp :: (M.Map String [Region]),identifier_Syn_BinOp :: String,isInModule_Syn_BinOp :: Bool,mtokenPos_Syn_BinOp :: Region,scopes_Syn_BinOp :: ([M.Map String (Bool, Region)]),variableStyle_Syn_BinOp :: DeterminedVariableStyle,warnings_Syn_BinOp :: ([String -> LintMessage])}+wrap_BinOp :: T_BinOp ->+              Inh_BinOp ->+              Syn_BinOp+wrap_BinOp sem (Inh_BinOp _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_BinOp _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_BinOp_AOr :: T_BinOp+sem_BinOp_AOr =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AOr+            {-# LINE 987 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 992 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_AOr_1 :: T_BinOp_1+                  sem_BinOp_AOr_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1009 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1014 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1019 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1024 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1029 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1034 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1039 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_AOr_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_AAnd :: T_BinOp+sem_BinOp_AAnd =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AAnd+            {-# LINE 1050 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1055 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_AAnd_1 :: T_BinOp_1+                  sem_BinOp_AAnd_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1072 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1077 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1082 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1087 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1092 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1097 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1102 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_AAnd_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_ALT :: T_BinOp+sem_BinOp_ALT =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ALT+            {-# LINE 1113 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1118 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_ALT_1 :: T_BinOp_1+                  sem_BinOp_ALT_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1135 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1140 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1145 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1150 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1155 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1160 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1165 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_ALT_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_AGT :: T_BinOp+sem_BinOp_AGT =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AGT+            {-# LINE 1176 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1181 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_AGT_1 :: T_BinOp_1+                  sem_BinOp_AGT_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1198 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1203 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1208 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1213 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1218 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1223 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1228 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_AGT_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_ALEQ :: T_BinOp+sem_BinOp_ALEQ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ALEQ+            {-# LINE 1239 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1244 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_ALEQ_1 :: T_BinOp_1+                  sem_BinOp_ALEQ_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1261 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1266 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1271 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1276 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1281 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1286 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1291 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_ALEQ_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_AGEQ :: T_BinOp+sem_BinOp_AGEQ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AGEQ+            {-# LINE 1302 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1307 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_AGEQ_1 :: T_BinOp_1+                  sem_BinOp_AGEQ_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1324 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1329 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1334 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1339 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1344 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1349 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1354 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_AGEQ_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_ANEq :: T_BinOp+sem_BinOp_ANEq =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ANEq+            {-# LINE 1365 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1370 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_ANEq_1 :: T_BinOp_1+                  sem_BinOp_ANEq_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1387 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1392 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1397 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1402 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1407 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1412 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1417 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_ANEq_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_AEq :: T_BinOp+sem_BinOp_AEq =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AEq+            {-# LINE 1428 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1433 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_AEq_1 :: T_BinOp_1+                  sem_BinOp_AEq_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1450 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1455 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1460 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1465 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1470 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1475 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1480 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_AEq_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_AConcatenate :: T_BinOp+sem_BinOp_AConcatenate =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AConcatenate+            {-# LINE 1491 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1496 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_AConcatenate_1 :: T_BinOp_1+                  sem_BinOp_AConcatenate_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1513 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1518 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1523 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1528 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1533 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1538 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1543 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_AConcatenate_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_APlus :: T_BinOp+sem_BinOp_APlus =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            APlus+            {-# LINE 1554 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1559 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_APlus_1 :: T_BinOp_1+                  sem_BinOp_APlus_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1576 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1581 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1586 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1591 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1596 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1601 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1606 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_APlus_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_BinMinus :: T_BinOp+sem_BinOp_BinMinus =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            BinMinus+            {-# LINE 1617 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1622 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_BinMinus_1 :: T_BinOp_1+                  sem_BinOp_BinMinus_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1639 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1644 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1649 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1654 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1659 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1664 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1669 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_BinMinus_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_AMultiply :: T_BinOp+sem_BinOp_AMultiply =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AMultiply+            {-# LINE 1680 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1685 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_AMultiply_1 :: T_BinOp_1+                  sem_BinOp_AMultiply_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1702 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1707 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1712 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1717 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1722 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1727 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1732 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_AMultiply_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_ADivide :: T_BinOp+sem_BinOp_ADivide =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ADivide+            {-# LINE 1743 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1748 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_ADivide_1 :: T_BinOp_1+                  sem_BinOp_ADivide_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1765 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1770 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1775 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1780 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1785 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1790 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1795 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_ADivide_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_AModulus :: T_BinOp+sem_BinOp_AModulus =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AModulus+            {-# LINE 1806 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1811 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_AModulus_1 :: T_BinOp_1+                  sem_BinOp_AModulus_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1828 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1833 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1838 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1843 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1848 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1853 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1858 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_AModulus_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+sem_BinOp_APower :: T_BinOp+sem_BinOp_APower =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            APower+            {-# LINE 1869 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 1874 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_BinOp_APower_1 :: T_BinOp_1+                  sem_BinOp_APower_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 1891 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 1896 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 1901 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 1906 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 1911 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 1916 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 1921 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_BinOp_APower_1)) of+       { ( sem_BinOp_1) ->+       ( _lhsOcopy,sem_BinOp_1) }) }) })+-- Block -------------------------------------------------------+-- cata+sem_Block :: Block ->+             T_Block+sem_Block (Block _stats _ret) =+    (sem_Block_Block (sem_MStatList _stats) (sem_AReturn _ret))+-- semantic domain+type T_Block = ( Block,T_Block_1)+type T_Block_1 = LintSettings ->+                 String ->+                 (M.Map String [Region]) ->+                 Bool ->+                 Bool ->+                 Bool ->+                 Int ->+                 Region ->+                 Int ->+                 ([M.Map String (Bool, Region)]) ->+                 DeterminedVariableStyle ->+                 ( (M.Map String [Region]),String,Bool,Bool,Region,([M.Map String (Bool, Region)]),Int,DeterminedVariableStyle,([String -> LintMessage]))+data Inh_Block = Inh_Block {config_Inh_Block :: LintSettings,funcName_Inh_Block :: String,globalDefinitions_Inh_Block :: (M.Map String [Region]),isInModule_Inh_Block :: Bool,isMeta_Inh_Block :: Bool,isRepeat_Inh_Block :: Bool,loopLevel_Inh_Block :: Int,mtokenPos_Inh_Block :: Region,scopeLevel_Inh_Block :: Int,scopes_Inh_Block :: ([M.Map String (Bool, Region)]),variableStyle_Inh_Block :: DeterminedVariableStyle}+data Syn_Block = Syn_Block {copy_Syn_Block :: Block,globalDefinitions_Syn_Block :: (M.Map String [Region]),identifier_Syn_Block :: String,isIfStatement_Syn_Block :: Bool,isInModule_Syn_Block :: Bool,mtokenPos_Syn_Block :: Region,scopes_Syn_Block :: ([M.Map String (Bool, Region)]),statementCount_Syn_Block :: Int,variableStyle_Syn_Block :: DeterminedVariableStyle,warnings_Syn_Block :: ([String -> LintMessage])}+wrap_Block :: T_Block ->+              Inh_Block ->+              Syn_Block+wrap_Block sem (Inh_Block _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIisRepeat _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIisRepeat _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_Block _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisIfStatement _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOstatementCount _lhsOvariableStyle _lhsOwarnings))+sem_Block_Block :: T_MStatList ->+                   T_AReturn ->+                   T_Block+sem_Block_Block stats_ ret_ =+    (case (ret_) of+     { ( _retIcopy,ret_1) ->+         (case (stats_) of+          { ( _statsIcopy,stats_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      Block _statsIcopy _retIcopy+                      {-# LINE 1967 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 1972 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Block_Block_1 :: T_Block_1+                            sem_Block_Block_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIisRepeat+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 1990 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _statsOscopes ->+                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisMeta+                                              {-# LINE 1995 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _statsOisMeta ->+                                       (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIconfig+                                               {-# LINE 2000 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _statsOconfig ->+                                        (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIvariableStyle+                                                {-# LINE 2005 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _statsOvariableStyle ->+                                         (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsImtokenPos+                                                 {-# LINE 2010 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _statsOmtokenPos ->+                                          (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIloopLevel+                                                  {-# LINE 2015 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _statsOloopLevel ->+                                           (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIisInModule+                                                   {-# LINE 2020 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _statsOisInModule ->+                                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIglobalDefinitions+                                                    {-# LINE 2025 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _statsOglobalDefinitions ->+                                             (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIfuncName+                                                     {-# LINE 2030 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _statsOfuncName ->+                                              (case (({-# LINE 297 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIscopeLevel + 1+                                                      {-# LINE 2035 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _statsOscopeLevel ->+                                               (case (stats_1 _statsOconfig _statsOfuncName _statsOglobalDefinitions _statsOisInModule _statsOisMeta _statsOloopLevel _statsOmtokenPos _statsOscopeLevel _statsOscopes _statsOvariableStyle) of+                                                { ( _statsIglobalDefinitions,_statsIidentifier,_statsIisIfStatement,_statsIisInModule,_statsImtokenPos,_statsIscopes,_statsIstatementCount,_statsIvariableStyle,_statsIwarnings) ->+                                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _statsIscopes+                                                            {-# LINE 2042 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _retOscopes ->+                                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _lhsIisMeta+                                                             {-# LINE 2047 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _retOisMeta ->+                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _statsIisInModule+                                                              {-# LINE 2052 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _retOisInModule ->+                                                       (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _statsIglobalDefinitions+                                                               {-# LINE 2057 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _retOglobalDefinitions ->+                                                        (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _lhsIconfig+                                                                {-# LINE 2062 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _retOconfig ->+                                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _statsIvariableStyle+                                                                 {-# LINE 2067 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _retOvariableStyle ->+                                                          (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIscopeLevel+                                                                  {-# LINE 2072 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _retOscopeLevel ->+                                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _statsImtokenPos+                                                                   {-# LINE 2077 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _retOmtokenPos ->+                                                            (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIloopLevel+                                                                    {-# LINE 2082 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _retOloopLevel ->+                                                             (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _lhsIfuncName+                                                                     {-# LINE 2087 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _retOfuncName ->+                                                              (case (ret_1 _retOconfig _retOfuncName _retOglobalDefinitions _retOisInModule _retOisMeta _retOloopLevel _retOmtokenPos _retOscopeLevel _retOscopes _retOvariableStyle) of+                                                               { ( _retIglobalDefinitions,_retIidentifier,_retIisInModule,_retImtokenPos,_retIscopes,_retIstatementCount,_retIvariableStyle,_retIwarnings) ->+                                                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           _retIglobalDefinitions+                                                                           {-# LINE 2094 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _lhsOglobalDefinitions ->+                                                                    (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            (const _statsIidentifier _retIidentifier)+                                                                            {-# LINE 2099 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _lhsOidentifier ->+                                                                     (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _statsIisIfStatement+                                                                             {-# LINE 2104 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _lhsOisIfStatement ->+                                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _retIisInModule+                                                                              {-# LINE 2109 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _lhsOisInModule ->+                                                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _retImtokenPos+                                                                               {-# LINE 2114 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOmtokenPos ->+                                                                        (case (({-# LINE 304 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                if _lhsIisRepeat then _retIscopes else tail _retIscopes+                                                                                {-# LINE 2119 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOscopes ->+                                                                         (case (({-# LINE 157 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _statsIstatementCount + _retIstatementCount+                                                                                 {-# LINE 2124 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOstatementCount ->+                                                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _retIvariableStyle+                                                                                  {-# LINE 2129 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOvariableStyle ->+                                                                           (case (({-# LINE 302 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _statsIwarnings ++ _retIwarnings+                                                                                   {-# LINE 2134 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _warnings_augmented_syn ->+                                                                            (case (({-# LINE 301 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    M.filterWithKey (\k (b, _) -> not (null k) && head k /= '_' && not b) (head _retIscopes)+                                                                                    {-# LINE 2139 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _deadVars ->+                                                                             (case (({-# LINE 298 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     lint_maxScopeDepth _lhsIconfig+                                                                                     {-# LINE 2144 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _maxScopeDepth ->+                                                                              (case (({-# LINE 302 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      if _maxScopeDepth     == 0 || _lhsIscopeLevel /= _maxScopeDepth     then id else+                                                                                        (:) $ warn _statsImtokenPos ScopePyramids+                                                                                      {-# LINE 2150 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _warnings_augmented_f2 ->+                                                                               (case (({-# LINE 302 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       if not (lint_unusedVars _lhsIconfig) || _lhsIisRepeat then id else+                                                                                         (++) $ M.foldrWithKey (\k (_, pos) ls -> warn pos (UnusedVariable k) : ls) [] _deadVars+                                                                                       {-# LINE 2156 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _warnings_augmented_f1 ->+                                                                                (case (({-# LINE 302 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        foldr ($) _warnings_augmented_syn [_warnings_augmented_f1, _warnings_augmented_f2]+                                                                                        {-# LINE 2161 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _lhsOwarnings ->+                                                                                 ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Block_Block_1)) of+                 { ( sem_Block_1) ->+                 ( _lhsOcopy,sem_Block_1) }) }) }) }) })+-- Declaration -------------------------------------------------+-- cata+sem_Declaration :: Declaration ->+                   T_Declaration+sem_Declaration ( x1,x2) =+    (sem_Declaration_Tuple (sem_PrefixExp x1) (sem_MaybeMExpr x2))+-- semantic domain+type T_Declaration = ( Declaration,T_Declaration_1)+type T_Declaration_1 = LintSettings ->+                       String ->+                       (M.Map String [Region]) ->+                       Bool ->+                       Bool ->+                       Bool ->+                       Int ->+                       Region ->+                       Int ->+                       ([M.Map String (Bool, Region)]) ->+                       DeterminedVariableStyle ->+                       ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_Declaration = Inh_Declaration {config_Inh_Declaration :: LintSettings,funcName_Inh_Declaration :: String,globalDefinitions_Inh_Declaration :: (M.Map String [Region]),isInModule_Inh_Declaration :: Bool,isMeta_Inh_Declaration :: Bool,localDefinition_Inh_Declaration :: Bool,loopLevel_Inh_Declaration :: Int,mtokenPos_Inh_Declaration :: Region,scopeLevel_Inh_Declaration :: Int,scopes_Inh_Declaration :: ([M.Map String (Bool, Region)]),variableStyle_Inh_Declaration :: DeterminedVariableStyle}+data Syn_Declaration = Syn_Declaration {copy_Syn_Declaration :: Declaration,globalDefinitions_Syn_Declaration :: (M.Map String [Region]),identifier_Syn_Declaration :: String,isInModule_Syn_Declaration :: Bool,mtokenPos_Syn_Declaration :: Region,scopes_Syn_Declaration :: ([M.Map String (Bool, Region)]),variableStyle_Syn_Declaration :: DeterminedVariableStyle,warnings_Syn_Declaration :: ([String -> LintMessage])}+wrap_Declaration :: T_Declaration ->+                    Inh_Declaration ->+                    Syn_Declaration+wrap_Declaration sem (Inh_Declaration _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIlocalDefinition _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIlocalDefinition _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_Declaration _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_Declaration_Tuple :: T_PrefixExp ->+                         T_MaybeMExpr ->+                         T_Declaration+sem_Declaration_Tuple x1_ x2_ =+    (case (x2_) of+     { ( _x2Icopy,x2_1) ->+         (case (x1_) of+          { ( _x1Icopy,_x1IhasSuffixes,_x1ImtokenPos,_x1IvarName,x1_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (_x1Icopy,_x2Icopy)+                      {-# LINE 2207 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 2212 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Declaration_Tuple_1 :: T_Declaration_1+                            sem_Declaration_Tuple_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIlocalDefinition+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIisMeta+                                             {-# LINE 2230 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _x1OisMeta ->+                                      (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIconfig+                                              {-# LINE 2235 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _x1Oconfig ->+                                       (case (({-# LINE 267 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               tokenLabel . fromMaybe (error "fromMaybe sem Declaration loc.var") $ _x1IvarName+                                               {-# LINE 2240 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _var ->+                                        (case (({-# LINE 275 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                if _lhsIlocalDefinition then+                                                  M.insert _var     (False, _x1ImtokenPos) (head _lhsIscopes) : tail _lhsIscopes+                                                 else if isJust _x1IvarName then+                                                          registerVariable _lhsIscopes _x1ImtokenPos _var     _x1IhasSuffixes+                                                      else+                                                          _lhsIscopes+                                                {-# LINE 2250 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _x1Oscopes ->+                                         (case (({-# LINE 263 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 Nothing+                                                 {-# LINE 2255 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _x1OvarBeingDefined ->+                                          (case (({-# LINE 259 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  False+                                                  {-# LINE 2260 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _x1OregisterVarUse ->+                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIvariableStyle+                                                   {-# LINE 2265 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _x1OvariableStyle ->+                                            (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIscopeLevel+                                                    {-# LINE 2270 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _x1OscopeLevel ->+                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsImtokenPos+                                                     {-# LINE 2275 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _x1OmtokenPos ->+                                              (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIloopLevel+                                                      {-# LINE 2280 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _x1OloopLevel ->+                                               (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIisInModule+                                                       {-# LINE 2285 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _x1OisInModule ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIglobalDefinitions+                                                        {-# LINE 2290 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _x1OglobalDefinitions ->+                                                 (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsIfuncName+                                                         {-# LINE 2295 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _x1OfuncName ->+                                                  (case (({-# LINE 261 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          False+                                                          {-# LINE 2300 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _x1OtopLevel ->+                                                   (case (({-# LINE 260 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           False+                                                           {-# LINE 2305 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _x1OinParentheses ->+                                                    (case (({-# LINE 258 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            False+                                                            {-# LINE 2310 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _x1OisNegation ->+                                                     (case (x1_1 _x1Oconfig _x1OfuncName _x1OglobalDefinitions _x1OinParentheses _x1OisInModule _x1OisMeta _x1OisNegation _x1OloopLevel _x1OmtokenPos _x1OregisterVarUse _x1OscopeLevel _x1Oscopes _x1OtopLevel _x1OvarBeingDefined _x1OvariableStyle) of+                                                      { ( _x1IglobalDefinitions,_x1Iidentifier,_x1IisInModule,_x1IisSimpleExpression,_x1IisSingleVar,_x1Iscopes,_x1IvariableStyle,_x1Iwarnings) ->+                                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _x1Iscopes+                                                                  {-# LINE 2317 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _x2Oscopes ->+                                                           (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIisMeta+                                                                   {-# LINE 2322 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _x2OisMeta ->+                                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _x1IisInModule+                                                                    {-# LINE 2327 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _x2OisInModule ->+                                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _x1IglobalDefinitions+                                                                     {-# LINE 2332 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _x2OglobalDefinitions ->+                                                              (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIconfig+                                                                      {-# LINE 2337 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _x2Oconfig ->+                                                               (case (({-# LINE 265 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       if _x1IhasSuffixes || not _lhsIlocalDefinition then Nothing else _x1IvarName+                                                                       {-# LINE 2342 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _x2OvarBeingDefined ->+                                                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _x1IvariableStyle+                                                                        {-# LINE 2347 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _x2OvariableStyle ->+                                                                 (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _lhsIscopeLevel+                                                                         {-# LINE 2352 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _x2OscopeLevel ->+                                                                  (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _x1ImtokenPos+                                                                          {-# LINE 2357 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _x2OmtokenPos ->+                                                                   (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           _lhsIloopLevel+                                                                           {-# LINE 2362 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _x2OloopLevel ->+                                                                    (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            _lhsIfuncName+                                                                            {-# LINE 2367 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _x2OfuncName ->+                                                                     (case (({-# LINE 262 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             False+                                                                             {-# LINE 2372 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _x2OisNegation ->+                                                                      (case (x2_1 _x2Oconfig _x2OfuncName _x2OglobalDefinitions _x2OisInModule _x2OisMeta _x2OisNegation _x2OloopLevel _x2OmtokenPos _x2OscopeLevel _x2Oscopes _x2OvarBeingDefined _x2OvariableStyle) of+                                                                       { ( _x2IglobalDefinitions,_x2Iidentifier,_x2IisInModule,_x2IisSingleVar,_x2ImtokenPos,_x2Iscopes,_x2IvariableStyle,_x2Iwarnings) ->+                                                                           (case (({-# LINE 282 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _x2IglobalDefinitions+                                                                                   {-# LINE 2379 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _globalDefinitions_augmented_syn ->+                                                                            (case (({-# LINE 282 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    if _lhsIisInModule || _lhsIlocalDefinition || isVariableLocal _lhsIscopes _var     || _x1IhasSuffixes then id else+                                                                                      M.insertWith (++) _var     [_x1ImtokenPos]+                                                                                    {-# LINE 2385 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _globalDefinitions_augmented_f1 ->+                                                                             (case (({-# LINE 282 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     foldr ($) _globalDefinitions_augmented_syn [_globalDefinitions_augmented_f1]+                                                                                     {-# LINE 2390 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOglobalDefinitions ->+                                                                              (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      (const _x1Iidentifier _x2Iidentifier)+                                                                                      {-# LINE 2395 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOidentifier ->+                                                                               (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _x2IisInModule+                                                                                       {-# LINE 2400 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _lhsOisInModule ->+                                                                                (case (({-# LINE 256 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        _x1ImtokenPos+                                                                                        {-# LINE 2405 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _lhsOmtokenPos ->+                                                                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         _x2Iscopes+                                                                                         {-# LINE 2410 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _lhsOscopes ->+                                                                                  (case (({-# LINE 268 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                          determineVariableStyle _var+                                                                                          {-# LINE 2415 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                          )) of+                                                                                   { _varStyle ->+                                                                                   (case (({-# LINE 257 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                           if _lhsIlocalDefinition then combineDeterminedVarStyle _lhsIvariableStyle _varStyle     else _lhsIvariableStyle+                                                                                           {-# LINE 2420 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                           )) of+                                                                                    { _lhsOvariableStyle ->+                                                                                    (case (({-# LINE 287 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                            _x1Iwarnings ++ _x2Iwarnings+                                                                                            {-# LINE 2425 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                            )) of+                                                                                     { _warnings_augmented_syn ->+                                                                                     (case (({-# LINE 269 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                             do+                                                                                               var <- _x1IvarName+                                                                                               if (Just var /= _x2IisSingleVar) then+                                                                                                   checkShadows _lhsIscopes var+                                                                                               else Nothing+                                                                                             {-# LINE 2434 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                             )) of+                                                                                      { _shadowWarning ->+                                                                                      (case (({-# LINE 287 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                              if not (lint_shadowing _lhsIconfig) || not _lhsIlocalDefinition || isNothing _shadowWarning     then id else+                                                                                                (:) . fromMaybe (error "fromMaybe sem Declaration +warnings") $ _shadowWarning+                                                                                              {-# LINE 2440 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                              )) of+                                                                                       { _warnings_augmented_f2 ->+                                                                                       (case (({-# LINE 287 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                               if not (lint_inconsistentVariableStyle _lhsIconfig) || not _lhsIlocalDefinition || not (variableStyleInconsistent _lhsIvariableStyle _varStyle    ) then id else+                                                                                                 (:) $ warn _x1ImtokenPos InconsistentVariableNaming+                                                                                               {-# LINE 2446 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                               )) of+                                                                                        { _warnings_augmented_f1 ->+                                                                                        (case (({-# LINE 287 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                foldr ($) _warnings_augmented_syn [_warnings_augmented_f1, _warnings_augmented_f2]+                                                                                                {-# LINE 2451 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                )) of+                                                                                         { _lhsOwarnings ->+                                                                                         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Declaration_Tuple_1)) of+                 { ( sem_Declaration_1) ->+                 ( _lhsOcopy,sem_Declaration_1) }) }) }) }) })+-- Else --------------------------------------------------------+-- cata+sem_Else :: Else ->+            T_Else+sem_Else (Prelude.Just x) =+    (sem_Else_Just (sem_MElse x))+sem_Else Prelude.Nothing =+    sem_Else_Nothing+-- semantic domain+type T_Else = ( Else,T_Else_1)+type T_Else_1 = LintSettings ->+                String ->+                (M.Map String [Region]) ->+                Bool ->+                Bool ->+                Int ->+                Region ->+                Int ->+                ([M.Map String (Bool, Region)]) ->+                DeterminedVariableStyle ->+                ( Bool,(M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_Else = Inh_Else {config_Inh_Else :: LintSettings,funcName_Inh_Else :: String,globalDefinitions_Inh_Else :: (M.Map String [Region]),isInModule_Inh_Else :: Bool,isMeta_Inh_Else :: Bool,loopLevel_Inh_Else :: Int,mtokenPos_Inh_Else :: Region,scopeLevel_Inh_Else :: Int,scopes_Inh_Else :: ([M.Map String (Bool, Region)]),variableStyle_Inh_Else :: DeterminedVariableStyle}+data Syn_Else = Syn_Else {copy_Syn_Else :: Else,elseExists_Syn_Else :: Bool,globalDefinitions_Syn_Else :: (M.Map String [Region]),identifier_Syn_Else :: String,isInModule_Syn_Else :: Bool,mtokenPos_Syn_Else :: Region,scopes_Syn_Else :: ([M.Map String (Bool, Region)]),variableStyle_Syn_Else :: DeterminedVariableStyle,warnings_Syn_Else :: ([String -> LintMessage])}+wrap_Else :: T_Else ->+             Inh_Else ->+             Syn_Else+wrap_Else sem (Inh_Else _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOelseExists,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_Else _lhsOcopy _lhsOelseExists _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_Else_Just :: T_MElse ->+                 T_Else+sem_Else_Just just_ =+    (case (just_) of+     { ( _justIcopy,just_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 Just _justIcopy+                 {-# LINE 2495 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 2500 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Else_Just_1 :: T_Else_1+                       sem_Else_Just_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 485 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        True+                                        {-# LINE 2517 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOelseExists ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 2522 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _justOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 2527 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _justOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 2532 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _justOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 2537 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _justOconfig ->+                                     (case (({-# LINE 484 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             M.empty : _lhsIscopes+                                             {-# LINE 2542 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _justOscopes ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 2547 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _justOvariableStyle ->+                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopeLevel+                                               {-# LINE 2552 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _justOscopeLevel ->+                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsImtokenPos+                                                {-# LINE 2557 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _justOmtokenPos ->+                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIloopLevel+                                                 {-# LINE 2562 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _justOloopLevel ->+                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIfuncName+                                                  {-# LINE 2567 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _justOfuncName ->+                                           (case (just_1 _justOconfig _justOfuncName _justOglobalDefinitions _justOisInModule _justOisMeta _justOloopLevel _justOmtokenPos _justOscopeLevel _justOscopes _justOvariableStyle) of+                                            { ( _justIelseExists,_justIglobalDefinitions,_justIidentifier,_justIisInModule,_justImtokenPos,_justIscopes,_justIstatementCount,_justIvariableStyle,_justIwarnings) ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _justIglobalDefinitions+                                                        {-# LINE 2574 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOglobalDefinitions ->+                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _justIidentifier+                                                         {-# LINE 2579 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOidentifier ->+                                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _justIisInModule+                                                          {-# LINE 2584 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOisInModule ->+                                                   (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _justImtokenPos+                                                           {-# LINE 2589 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOmtokenPos ->+                                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _justIscopes+                                                            {-# LINE 2594 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOscopes ->+                                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _justIvariableStyle+                                                             {-# LINE 2599 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOvariableStyle ->+                                                      (case (({-# LINE 487 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _justIwarnings+                                                              {-# LINE 2604 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _warnings_augmented_syn ->+                                                       (case (({-# LINE 486 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               Region (rgStart _justImtokenPos) (customAdvanceToken (rgStart _justImtokenPos) T.Else)+                                                               {-# LINE 2609 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _keywordPos ->+                                                        (case (({-# LINE 487 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                if not (lint_emptyBlocks _lhsIconfig) || _justIstatementCount > 0 then id else+                                                                  (:) $ warn _keywordPos     EmptyElse+                                                                {-# LINE 2615 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _warnings_augmented_f1 ->+                                                         (case (({-# LINE 487 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                 {-# LINE 2620 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOwarnings ->+                                                          ( _lhsOelseExists,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Else_Just_1)) of+            { ( sem_Else_1) ->+            ( _lhsOcopy,sem_Else_1) }) }) }) })+sem_Else_Nothing :: T_Else+sem_Else_Nothing =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Nothing+            {-# LINE 2631 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 2636 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_Else_Nothing_1 :: T_Else_1+                  sem_Else_Nothing_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 202 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   False+                                   {-# LINE 2653 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOelseExists ->+                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    _lhsIglobalDefinitions+                                    {-# LINE 2658 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOglobalDefinitions ->+                             (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     unknownIdentifier+                                     {-# LINE 2663 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOidentifier ->+                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsIisInModule+                                      {-# LINE 2668 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisInModule ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 2673 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 2678 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 2683 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 2688 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOelseExists,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_Else_Nothing_1)) of+       { ( sem_Else_1) ->+       ( _lhsOcopy,sem_Else_1) }) }) })+-- ElseIf ------------------------------------------------------+-- cata+sem_ElseIf :: ElseIf ->+              T_ElseIf+sem_ElseIf ( x1,x2) =+    (sem_ElseIf_Tuple (sem_MExpr x1) (sem_Block x2))+-- semantic domain+type T_ElseIf = ( ElseIf,T_ElseIf_1)+type T_ElseIf_1 = LintSettings ->+                  String ->+                  (M.Map String [Region]) ->+                  Bool ->+                  Bool ->+                  Int ->+                  Region ->+                  Int ->+                  ([M.Map String (Bool, Region)]) ->+                  DeterminedVariableStyle ->+                  ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_ElseIf = Inh_ElseIf {config_Inh_ElseIf :: LintSettings,funcName_Inh_ElseIf :: String,globalDefinitions_Inh_ElseIf :: (M.Map String [Region]),isInModule_Inh_ElseIf :: Bool,isMeta_Inh_ElseIf :: Bool,loopLevel_Inh_ElseIf :: Int,mtokenPos_Inh_ElseIf :: Region,scopeLevel_Inh_ElseIf :: Int,scopes_Inh_ElseIf :: ([M.Map String (Bool, Region)]),variableStyle_Inh_ElseIf :: DeterminedVariableStyle}+data Syn_ElseIf = Syn_ElseIf {copy_Syn_ElseIf :: ElseIf,globalDefinitions_Syn_ElseIf :: (M.Map String [Region]),identifier_Syn_ElseIf :: String,isInModule_Syn_ElseIf :: Bool,mtokenPos_Syn_ElseIf :: Region,scopes_Syn_ElseIf :: ([M.Map String (Bool, Region)]),variableStyle_Syn_ElseIf :: DeterminedVariableStyle,warnings_Syn_ElseIf :: ([String -> LintMessage])}+wrap_ElseIf :: T_ElseIf ->+               Inh_ElseIf ->+               Syn_ElseIf+wrap_ElseIf sem (Inh_ElseIf _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_ElseIf _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_ElseIf_Tuple :: T_MExpr ->+                    T_Block ->+                    T_ElseIf+sem_ElseIf_Tuple x1_ x2_ =+    (case (x2_) of+     { ( _x2Icopy,x2_1) ->+         (case (x1_) of+          { ( _x1Icopy,_x1ImtokenPos,x1_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (_x1Icopy,_x2Icopy)+                      {-# LINE 2733 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 2738 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_ElseIf_Tuple_1 :: T_ElseIf_1+                            sem_ElseIf_Tuple_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIisMeta+                                             {-# LINE 2755 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _x2OisMeta ->+                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisInModule+                                              {-# LINE 2760 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _x1OisInModule ->+                                       (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIvariableStyle+                                               {-# LINE 2765 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _x1OvariableStyle ->+                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIscopes+                                                {-# LINE 2770 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _x1Oscopes ->+                                         (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIscopeLevel+                                                 {-# LINE 2775 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _x1OscopeLevel ->+                                          (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsImtokenPos+                                                  {-# LINE 2780 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _x1OmtokenPos ->+                                           (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIloopLevel+                                                   {-# LINE 2785 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _x1OloopLevel ->+                                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisMeta+                                                    {-# LINE 2790 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _x1OisMeta ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 2795 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _x1OglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 2800 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _x1OfuncName ->+                                               (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIconfig+                                                       {-# LINE 2805 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _x1Oconfig ->+                                                (case (({-# LINE 470 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        Nothing+                                                        {-# LINE 2810 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _x1OvarBeingDefined ->+                                                 (case (({-# LINE 469 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         True+                                                         {-# LINE 2815 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _x1OtopLevel ->+                                                  (case (({-# LINE 468 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          False+                                                          {-# LINE 2820 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _x1OinParentheses ->+                                                   (case (({-# LINE 467 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           False+                                                           {-# LINE 2825 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _x1OisNegation ->+                                                    (case (x1_1 _x1Oconfig _x1OfuncName _x1OglobalDefinitions _x1OinParentheses _x1OisInModule _x1OisMeta _x1OisNegation _x1OloopLevel _x1OmtokenPos _x1OscopeLevel _x1Oscopes _x1OtopLevel _x1OvarBeingDefined _x1OvariableStyle) of+                                                     { ( _x1IglobalDefinitions,_x1Iidentifier,_x1IisInModule,_x1IisSimpleExpression,_x1IisSingleVar,_x1Iscopes,_x1IvariableStyle,_x1Iwarnings) ->+                                                         (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _x1IisInModule+                                                                 {-# LINE 2832 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _x2OisInModule ->+                                                          (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _x1IglobalDefinitions+                                                                  {-# LINE 2837 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _x2OglobalDefinitions ->+                                                           (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIconfig+                                                                   {-# LINE 2842 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _x2Oconfig ->+                                                            (case (({-# LINE 471 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    M.empty : _x1Iscopes+                                                                    {-# LINE 2847 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _x2Oscopes ->+                                                             (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _x1IvariableStyle+                                                                     {-# LINE 2852 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _x2OvariableStyle ->+                                                              (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIscopeLevel+                                                                      {-# LINE 2857 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _x2OscopeLevel ->+                                                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _x1ImtokenPos+                                                                       {-# LINE 2862 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _x2OmtokenPos ->+                                                                (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _lhsIloopLevel+                                                                        {-# LINE 2867 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _x2OloopLevel ->+                                                                 (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _lhsIfuncName+                                                                         {-# LINE 2872 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _x2OfuncName ->+                                                                  (case (({-# LINE 472 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          False+                                                                          {-# LINE 2877 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _x2OisRepeat ->+                                                                   (case (x2_1 _x2Oconfig _x2OfuncName _x2OglobalDefinitions _x2OisInModule _x2OisMeta _x2OisRepeat _x2OloopLevel _x2OmtokenPos _x2OscopeLevel _x2Oscopes _x2OvariableStyle) of+                                                                    { ( _x2IglobalDefinitions,_x2Iidentifier,_x2IisIfStatement,_x2IisInModule,_x2ImtokenPos,_x2Iscopes,_x2IstatementCount,_x2IvariableStyle,_x2Iwarnings) ->+                                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _x2IglobalDefinitions+                                                                                {-# LINE 2884 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOglobalDefinitions ->+                                                                         (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 (const _x1Iidentifier _x2Iidentifier)+                                                                                 {-# LINE 2889 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOidentifier ->+                                                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _x2IisInModule+                                                                                  {-# LINE 2894 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOisInModule ->+                                                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _x2ImtokenPos+                                                                                   {-# LINE 2899 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOmtokenPos ->+                                                                            (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _x2Iscopes+                                                                                    {-# LINE 2904 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOscopes ->+                                                                             (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _x2IvariableStyle+                                                                                     {-# LINE 2909 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOvariableStyle ->+                                                                              (case (({-# LINE 474 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _x1Iwarnings ++ _x2Iwarnings+                                                                                      {-# LINE 2914 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _warnings_augmented_syn ->+                                                                               (case (({-# LINE 473 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       Region (rgStart _lhsImtokenPos) (customAdvanceToken (rgStart _lhsImtokenPos) T.Elseif)+                                                                                       {-# LINE 2919 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _keywordPos ->+                                                                                (case (({-# LINE 474 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        if not (lint_emptyBlocks _lhsIconfig) || _x2IstatementCount > 0 then id else+                                                                                          (:) $ warn _keywordPos     EmptyElseIf+                                                                                        {-# LINE 2925 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _warnings_augmented_f1 ->+                                                                                 (case (({-# LINE 474 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                                         {-# LINE 2930 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _lhsOwarnings ->+                                                                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_ElseIf_Tuple_1)) of+                 { ( sem_ElseIf_1) ->+                 ( _lhsOcopy,sem_ElseIf_1) }) }) }) }) })+-- ElseIfList --------------------------------------------------+-- cata+sem_ElseIfList :: ElseIfList ->+                  T_ElseIfList+sem_ElseIfList list =+    (Prelude.foldr sem_ElseIfList_Cons sem_ElseIfList_Nil (Prelude.map sem_MElseIf list))+-- semantic domain+type T_ElseIfList = ( ElseIfList,T_ElseIfList_1)+type T_ElseIfList_1 = LintSettings ->+                      String ->+                      (M.Map String [Region]) ->+                      Bool ->+                      Bool ->+                      Int ->+                      Region ->+                      Int ->+                      ([M.Map String (Bool, Region)]) ->+                      DeterminedVariableStyle ->+                      ( Bool,(M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_ElseIfList = Inh_ElseIfList {config_Inh_ElseIfList :: LintSettings,funcName_Inh_ElseIfList :: String,globalDefinitions_Inh_ElseIfList :: (M.Map String [Region]),isInModule_Inh_ElseIfList :: Bool,isMeta_Inh_ElseIfList :: Bool,loopLevel_Inh_ElseIfList :: Int,mtokenPos_Inh_ElseIfList :: Region,scopeLevel_Inh_ElseIfList :: Int,scopes_Inh_ElseIfList :: ([M.Map String (Bool, Region)]),variableStyle_Inh_ElseIfList :: DeterminedVariableStyle}+data Syn_ElseIfList = Syn_ElseIfList {copy_Syn_ElseIfList :: ElseIfList,elseExists_Syn_ElseIfList :: Bool,globalDefinitions_Syn_ElseIfList :: (M.Map String [Region]),identifier_Syn_ElseIfList :: String,isInModule_Syn_ElseIfList :: Bool,mtokenPos_Syn_ElseIfList :: Region,scopes_Syn_ElseIfList :: ([M.Map String (Bool, Region)]),variableStyle_Syn_ElseIfList :: DeterminedVariableStyle,warnings_Syn_ElseIfList :: ([String -> LintMessage])}+wrap_ElseIfList :: T_ElseIfList ->+                   Inh_ElseIfList ->+                   Syn_ElseIfList+wrap_ElseIfList sem (Inh_ElseIfList _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOelseExists,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_ElseIfList _lhsOcopy _lhsOelseExists _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_ElseIfList_Cons :: T_MElseIf ->+                       T_ElseIfList ->+                       T_ElseIfList+sem_ElseIfList_Cons hd_ tl_ =+    (case (tl_) of+     { ( _tlIcopy,tl_1) ->+         (case (hd_) of+          { ( _hdIcopy,hd_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (:) _hdIcopy _tlIcopy+                      {-# LINE 2975 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 2980 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_ElseIfList_Cons_1 :: T_ElseIfList_1+                            sem_ElseIfList_Cons_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 459 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             True+                                             {-# LINE 2997 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _lhsOelseExists ->+                                      (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIscopes+                                              {-# LINE 3002 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _hdOscopes ->+                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIisMeta+                                               {-# LINE 3007 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _hdOisMeta ->+                                        (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIconfig+                                                {-# LINE 3012 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _hdOconfig ->+                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIvariableStyle+                                                 {-# LINE 3017 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _hdOvariableStyle ->+                                          (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIscopeLevel+                                                  {-# LINE 3022 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _hdOscopeLevel ->+                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsImtokenPos+                                                   {-# LINE 3027 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _hdOmtokenPos ->+                                            (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIloopLevel+                                                    {-# LINE 3032 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _hdOloopLevel ->+                                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIisInModule+                                                     {-# LINE 3037 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _hdOisInModule ->+                                              (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIglobalDefinitions+                                                      {-# LINE 3042 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _hdOglobalDefinitions ->+                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIfuncName+                                                       {-# LINE 3047 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _hdOfuncName ->+                                                (case (hd_1 _hdOconfig _hdOfuncName _hdOglobalDefinitions _hdOisInModule _hdOisMeta _hdOloopLevel _hdOmtokenPos _hdOscopeLevel _hdOscopes _hdOvariableStyle) of+                                                 { ( _hdIglobalDefinitions,_hdIidentifier,_hdIisInModule,_hdImtokenPos,_hdIscopes,_hdIvariableStyle,_hdIwarnings) ->+                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _hdIscopes+                                                             {-# LINE 3054 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _tlOscopes ->+                                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _lhsIisMeta+                                                              {-# LINE 3059 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _tlOisMeta ->+                                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _hdIisInModule+                                                               {-# LINE 3064 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _tlOisInModule ->+                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _hdIglobalDefinitions+                                                                {-# LINE 3069 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _tlOglobalDefinitions ->+                                                         (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _lhsIconfig+                                                                 {-# LINE 3074 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _tlOconfig ->+                                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _hdIvariableStyle+                                                                  {-# LINE 3079 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _tlOvariableStyle ->+                                                           (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIscopeLevel+                                                                   {-# LINE 3084 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _tlOscopeLevel ->+                                                            (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _hdImtokenPos+                                                                    {-# LINE 3089 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _tlOmtokenPos ->+                                                             (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _lhsIloopLevel+                                                                     {-# LINE 3094 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _tlOloopLevel ->+                                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIfuncName+                                                                      {-# LINE 3099 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _tlOfuncName ->+                                                               (case (tl_1 _tlOconfig _tlOfuncName _tlOglobalDefinitions _tlOisInModule _tlOisMeta _tlOloopLevel _tlOmtokenPos _tlOscopeLevel _tlOscopes _tlOvariableStyle) of+                                                                { ( _tlIelseExists,_tlIglobalDefinitions,_tlIidentifier,_tlIisInModule,_tlImtokenPos,_tlIscopes,_tlIvariableStyle,_tlIwarnings) ->+                                                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            _tlIglobalDefinitions+                                                                            {-# LINE 3106 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _lhsOglobalDefinitions ->+                                                                     (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             (const _hdIidentifier _tlIidentifier)+                                                                             {-# LINE 3111 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _lhsOidentifier ->+                                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _tlIisInModule+                                                                              {-# LINE 3116 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _lhsOisInModule ->+                                                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _tlImtokenPos+                                                                               {-# LINE 3121 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOmtokenPos ->+                                                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _tlIscopes+                                                                                {-# LINE 3126 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOscopes ->+                                                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _tlIvariableStyle+                                                                                 {-# LINE 3131 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOvariableStyle ->+                                                                          (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _hdIwarnings ++ _tlIwarnings+                                                                                  {-# LINE 3136 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOwarnings ->+                                                                           ( _lhsOelseExists,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_ElseIfList_Cons_1)) of+                 { ( sem_ElseIfList_1) ->+                 ( _lhsOcopy,sem_ElseIfList_1) }) }) }) }) })+sem_ElseIfList_Nil :: T_ElseIfList+sem_ElseIfList_Nil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            []+            {-# LINE 3147 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 3152 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_ElseIfList_Nil_1 :: T_ElseIfList_1+                  sem_ElseIfList_Nil_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 202 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   False+                                   {-# LINE 3169 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOelseExists ->+                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    _lhsIglobalDefinitions+                                    {-# LINE 3174 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOglobalDefinitions ->+                             (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     unknownIdentifier+                                     {-# LINE 3179 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOidentifier ->+                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsIisInModule+                                      {-# LINE 3184 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisInModule ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 3189 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 3194 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 3199 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 3204 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOelseExists,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_ElseIfList_Nil_1)) of+       { ( sem_ElseIfList_1) ->+       ( _lhsOcopy,sem_ElseIfList_1) }) }) })+-- Expr --------------------------------------------------------+-- cata+sem_Expr :: Expr ->+            T_Expr+sem_Expr (ANil) =+    (sem_Expr_ANil)+sem_Expr (AFalse) =+    (sem_Expr_AFalse)+sem_Expr (ATrue) =+    (sem_Expr_ATrue)+sem_Expr (ANumber _num) =+    (sem_Expr_ANumber _num)+sem_Expr (AString _str) =+    (sem_Expr_AString (sem_MToken _str))+sem_Expr (AVarArg) =+    (sem_Expr_AVarArg)+sem_Expr (AnonymousFunc _pars _body) =+    (sem_Expr_AnonymousFunc _pars (sem_Block _body))+sem_Expr (APrefixExpr _pexpr) =+    (sem_Expr_APrefixExpr (sem_PrefixExp _pexpr))+sem_Expr (ATableConstructor _fields) =+    (sem_Expr_ATableConstructor (sem_FieldList _fields))+sem_Expr (BinOpExpr _op _left _right) =+    (sem_Expr_BinOpExpr (sem_BinOp _op) (sem_MExpr _left) (sem_MExpr _right))+sem_Expr (UnOpExpr _op _right) =+    (sem_Expr_UnOpExpr (sem_UnOp _op) (sem_MExpr _right))+-- semantic domain+type T_Expr = ( Expr,T_Expr_1)+type T_Expr_1 = LintSettings ->+                String ->+                (M.Map String [Region]) ->+                Bool ->+                Bool ->+                Bool ->+                Bool ->+                Int ->+                Region ->+                Int ->+                ([M.Map String (Bool, Region)]) ->+                Bool ->+                (Maybe MToken) ->+                DeterminedVariableStyle ->+                ( (M.Map String [Region]),String,Bool,Bool,(Maybe MToken),Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_Expr = Inh_Expr {config_Inh_Expr :: LintSettings,funcName_Inh_Expr :: String,globalDefinitions_Inh_Expr :: (M.Map String [Region]),inParentheses_Inh_Expr :: Bool,isInModule_Inh_Expr :: Bool,isMeta_Inh_Expr :: Bool,isNegation_Inh_Expr :: Bool,loopLevel_Inh_Expr :: Int,mtokenPos_Inh_Expr :: Region,scopeLevel_Inh_Expr :: Int,scopes_Inh_Expr :: ([M.Map String (Bool, Region)]),topLevel_Inh_Expr :: Bool,varBeingDefined_Inh_Expr :: (Maybe MToken),variableStyle_Inh_Expr :: DeterminedVariableStyle}+data Syn_Expr = Syn_Expr {copy_Syn_Expr :: Expr,globalDefinitions_Syn_Expr :: (M.Map String [Region]),identifier_Syn_Expr :: String,isInModule_Syn_Expr :: Bool,isSimpleExpression_Syn_Expr :: Bool,isSingleVar_Syn_Expr :: (Maybe MToken),mtokenPos_Syn_Expr :: Region,scopes_Syn_Expr :: ([M.Map String (Bool, Region)]),variableStyle_Syn_Expr :: DeterminedVariableStyle,warnings_Syn_Expr :: ([String -> LintMessage])}+wrap_Expr :: T_Expr ->+             Inh_Expr ->+             Syn_Expr+wrap_Expr sem (Inh_Expr _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIinParentheses _lhsIisInModule _lhsIisMeta _lhsIisNegation _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsItopLevel _lhsIvarBeingDefined _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIinParentheses _lhsIisInModule _lhsIisMeta _lhsIisNegation _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsItopLevel _lhsIvarBeingDefined _lhsIvariableStyle+     in  (Syn_Expr _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOisSimpleExpression _lhsOisSingleVar _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_Expr_ANil :: T_Expr+sem_Expr_ANil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ANil+            {-# LINE 3267 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 3272 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_Expr_ANil_1 :: T_Expr_1+                  sem_Expr_ANil_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIinParentheses+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIisNegation+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsItopLevel+                         _lhsIvarBeingDefined+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 3293 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 3298 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 3303 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      True+                                      {-# LINE 3308 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisSimpleExpression ->+                               (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       Nothing+                                       {-# LINE 3313 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOisSingleVar ->+                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsImtokenPos+                                        {-# LINE 3318 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOmtokenPos ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 3323 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOscopes ->+                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIvariableStyle+                                          {-# LINE 3328 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOvariableStyle ->+                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           []+                                           {-# LINE 3333 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lhsOwarnings ->+                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }))+              in  sem_Expr_ANil_1)) of+       { ( sem_Expr_1) ->+       ( _lhsOcopy,sem_Expr_1) }) }) })+sem_Expr_AFalse :: T_Expr+sem_Expr_AFalse =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AFalse+            {-# LINE 3344 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 3349 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_Expr_AFalse_1 :: T_Expr_1+                  sem_Expr_AFalse_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIinParentheses+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIisNegation+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsItopLevel+                         _lhsIvarBeingDefined+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 3370 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 3375 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 3380 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      True+                                      {-# LINE 3385 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisSimpleExpression ->+                               (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       Nothing+                                       {-# LINE 3390 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOisSingleVar ->+                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsImtokenPos+                                        {-# LINE 3395 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOmtokenPos ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 3400 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOscopes ->+                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIvariableStyle+                                          {-# LINE 3405 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOvariableStyle ->+                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           []+                                           {-# LINE 3410 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lhsOwarnings ->+                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }))+              in  sem_Expr_AFalse_1)) of+       { ( sem_Expr_1) ->+       ( _lhsOcopy,sem_Expr_1) }) }) })+sem_Expr_ATrue :: T_Expr+sem_Expr_ATrue =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ATrue+            {-# LINE 3421 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 3426 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_Expr_ATrue_1 :: T_Expr_1+                  sem_Expr_ATrue_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIinParentheses+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIisNegation+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsItopLevel+                         _lhsIvarBeingDefined+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 3447 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 3452 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 3457 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      True+                                      {-# LINE 3462 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisSimpleExpression ->+                               (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       Nothing+                                       {-# LINE 3467 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOisSingleVar ->+                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsImtokenPos+                                        {-# LINE 3472 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOmtokenPos ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 3477 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOscopes ->+                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIvariableStyle+                                          {-# LINE 3482 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOvariableStyle ->+                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           []+                                           {-# LINE 3487 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lhsOwarnings ->+                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }))+              in  sem_Expr_ATrue_1)) of+       { ( sem_Expr_1) ->+       ( _lhsOcopy,sem_Expr_1) }) }) })+sem_Expr_ANumber :: String ->+                    T_Expr+sem_Expr_ANumber num_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ANumber num_+            {-# LINE 3499 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 3504 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_Expr_ANumber_1 :: T_Expr_1+                  sem_Expr_ANumber_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIinParentheses+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIisNegation+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsItopLevel+                         _lhsIvarBeingDefined+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 3525 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 3530 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 3535 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      True+                                      {-# LINE 3540 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisSimpleExpression ->+                               (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       Nothing+                                       {-# LINE 3545 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOisSingleVar ->+                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsImtokenPos+                                        {-# LINE 3550 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOmtokenPos ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 3555 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOscopes ->+                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIvariableStyle+                                          {-# LINE 3560 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOvariableStyle ->+                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           []+                                           {-# LINE 3565 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lhsOwarnings ->+                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }))+              in  sem_Expr_ANumber_1)) of+       { ( sem_Expr_1) ->+       ( _lhsOcopy,sem_Expr_1) }) }) })+sem_Expr_AString :: T_MToken ->+                    T_Expr+sem_Expr_AString str_ =+    (case (str_) of+     { ( _strIcopy,_strImtok,_strImtokenPos,str_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 AString _strIcopy+                 {-# LINE 3579 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 3584 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Expr_AString_1 :: T_Expr_1+                       sem_Expr_AString_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIinParentheses+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIisNegation+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsItopLevel+                              _lhsIvarBeingDefined+                              _lhsIvariableStyle ->+                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIglobalDefinitions+                                        {-# LINE 3605 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _strOglobalDefinitions ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 3610 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _strOscopes ->+                                  (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsImtokenPos+                                          {-# LINE 3615 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _strOmtokenPos ->+                                   (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIisMeta+                                           {-# LINE 3620 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _strOisMeta ->+                                    (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIisInModule+                                            {-# LINE 3625 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _strOisInModule ->+                                     (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIfuncName+                                             {-# LINE 3630 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _strOfuncName ->+                                      (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIconfig+                                              {-# LINE 3635 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _strOconfig ->+                                       (case (str_1 _strOconfig _strOfuncName _strOglobalDefinitions _strOisInModule _strOisMeta _strOmtokenPos _strOscopes) of+                                        { ( _strIglobalDefinitions,_strIidentifier,_strIisInModule,_strIscopes,_strIwarnings) ->+                                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _strIglobalDefinitions+                                                    {-# LINE 3642 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _lhsOglobalDefinitions ->+                                             (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _strIidentifier+                                                     {-# LINE 3647 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _lhsOidentifier ->+                                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _strIisInModule+                                                      {-# LINE 3652 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _lhsOisInModule ->+                                               (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       True+                                                       {-# LINE 3657 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _lhsOisSimpleExpression ->+                                                (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        Nothing+                                                        {-# LINE 3662 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOisSingleVar ->+                                                 (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _strImtokenPos+                                                         {-# LINE 3667 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOmtokenPos ->+                                                  (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _strIscopes+                                                          {-# LINE 3672 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOscopes ->+                                                   (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _lhsIvariableStyle+                                                           {-# LINE 3677 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOvariableStyle ->+                                                    (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _strIwarnings+                                                            {-# LINE 3682 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOwarnings ->+                                                     ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Expr_AString_1)) of+            { ( sem_Expr_1) ->+            ( _lhsOcopy,sem_Expr_1) }) }) }) })+sem_Expr_AVarArg :: T_Expr+sem_Expr_AVarArg =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AVarArg+            {-# LINE 3693 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 3698 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_Expr_AVarArg_1 :: T_Expr_1+                  sem_Expr_AVarArg_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIinParentheses+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIisNegation+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsItopLevel+                         _lhsIvarBeingDefined+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 3719 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 3724 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 3729 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 567 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      False+                                      {-# LINE 3734 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisSimpleExpression ->+                               (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       Nothing+                                       {-# LINE 3739 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOisSingleVar ->+                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsImtokenPos+                                        {-# LINE 3744 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOmtokenPos ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 3749 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOscopes ->+                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIvariableStyle+                                          {-# LINE 3754 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOvariableStyle ->+                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           []+                                           {-# LINE 3759 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lhsOwarnings ->+                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }))+              in  sem_Expr_AVarArg_1)) of+       { ( sem_Expr_1) ->+       ( _lhsOcopy,sem_Expr_1) }) }) })+sem_Expr_AnonymousFunc :: ([MToken]) ->+                          T_Block ->+                          T_Expr+sem_Expr_AnonymousFunc pars_ body_ =+    (case (body_) of+     { ( _bodyIcopy,body_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 AnonymousFunc pars_ _bodyIcopy+                 {-# LINE 3774 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 3779 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Expr_AnonymousFunc_1 :: T_Expr_1+                       sem_Expr_AnonymousFunc_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIinParentheses+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIisNegation+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsItopLevel+                              _lhsIvarBeingDefined+                              _lhsIvariableStyle ->+                                (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIisInModule+                                        {-# LINE 3800 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _bodyOisInModule ->+                                 (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIglobalDefinitions+                                         {-# LINE 3805 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _bodyOglobalDefinitions ->+                                  (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIconfig+                                          {-# LINE 3810 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _bodyOconfig ->+                                   (case (({-# LINE 572 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIisMeta || findSelf pars_+                                           {-# LINE 3815 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _bodyOisMeta ->+                                    (case (({-# LINE 569 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            M.fromList $ map (\mt -> (tokenLabel mt, (not . lint_unusedParameters $ _lhsIconfig, mpos mt))) pars_+                                            {-# LINE 3820 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _introduces ->+                                     (case (({-# LINE 570 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _introduces     : _lhsIscopes+                                             {-# LINE 3825 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _bodyOscopes ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 3830 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _bodyOvariableStyle ->+                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopeLevel+                                               {-# LINE 3835 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _bodyOscopeLevel ->+                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsImtokenPos+                                                {-# LINE 3840 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _bodyOmtokenPos ->+                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIloopLevel+                                                 {-# LINE 3845 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _bodyOloopLevel ->+                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIfuncName+                                                  {-# LINE 3850 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _bodyOfuncName ->+                                           (case (({-# LINE 571 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   False+                                                   {-# LINE 3855 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _bodyOisRepeat ->+                                            (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                             { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                 (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _bodyIglobalDefinitions+                                                         {-# LINE 3862 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOglobalDefinitions ->+                                                  (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _bodyIidentifier+                                                          {-# LINE 3867 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOidentifier ->+                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _bodyIisInModule+                                                           {-# LINE 3872 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOisInModule ->+                                                    (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            True+                                                            {-# LINE 3877 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOisSimpleExpression ->+                                                     (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             Nothing+                                                             {-# LINE 3882 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOisSingleVar ->+                                                      (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _bodyImtokenPos+                                                              {-# LINE 3887 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOmtokenPos ->+                                                       (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _bodyIscopes+                                                               {-# LINE 3892 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOscopes ->+                                                        (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _bodyIvariableStyle+                                                                {-# LINE 3897 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOvariableStyle ->+                                                         (case (({-# LINE 575 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _bodyIwarnings+                                                                 {-# LINE 3902 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _warnings_augmented_syn ->+                                                          (case (({-# LINE 573 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  filter (/= MToken emptyRg VarArg) $ pars_+                                                                  {-# LINE 3907 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _argIdentifiers ->+                                                           (case (({-# LINE 575 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   if not (lint_shadowing _lhsIconfig) then id else+                                                                     (++) . catMaybes . map (checkShadows _lhsIscopes) $ _argIdentifiers+                                                                   {-# LINE 3913 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _warnings_augmented_f1 ->+                                                            (case (({-# LINE 575 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                    {-# LINE 3918 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _lhsOwarnings ->+                                                             ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Expr_AnonymousFunc_1)) of+            { ( sem_Expr_1) ->+            ( _lhsOcopy,sem_Expr_1) }) }) }) })+sem_Expr_APrefixExpr :: T_PrefixExp ->+                        T_Expr+sem_Expr_APrefixExpr pexpr_ =+    (case (pexpr_) of+     { ( _pexprIcopy,_pexprIhasSuffixes,_pexprImtokenPos,_pexprIvarName,pexpr_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 APrefixExpr _pexprIcopy+                 {-# LINE 3932 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 3937 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Expr_APrefixExpr_1 :: T_Expr_1+                       sem_Expr_APrefixExpr_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIinParentheses+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIisNegation+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsItopLevel+                              _lhsIvarBeingDefined+                              _lhsIvariableStyle ->+                                (case (({-# LINE 178 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvarBeingDefined+                                        {-# LINE 3958 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _pexprOvarBeingDefined ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 3963 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _pexprOscopes ->+                                  (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisMeta+                                          {-# LINE 3968 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _pexprOisMeta ->+                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIisInModule+                                           {-# LINE 3973 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _pexprOisInModule ->+                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIglobalDefinitions+                                            {-# LINE 3978 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _pexprOglobalDefinitions ->+                                     (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIconfig+                                             {-# LINE 3983 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _pexprOconfig ->+                                      (case (({-# LINE 578 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              True+                                              {-# LINE 3988 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _pexprOregisterVarUse ->+                                       (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIvariableStyle+                                               {-# LINE 3993 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _pexprOvariableStyle ->+                                        (case (({-# LINE 182 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsItopLevel+                                                {-# LINE 3998 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _pexprOtopLevel ->+                                         (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIscopeLevel+                                                 {-# LINE 4003 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _pexprOscopeLevel ->+                                          (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsImtokenPos+                                                  {-# LINE 4008 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _pexprOmtokenPos ->+                                           (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIloopLevel+                                                   {-# LINE 4013 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _pexprOloopLevel ->+                                            (case (({-# LINE 169 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisNegation+                                                    {-# LINE 4018 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _pexprOisNegation ->+                                             (case (({-# LINE 181 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIinParentheses+                                                     {-# LINE 4023 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _pexprOinParentheses ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 4028 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _pexprOfuncName ->+                                               (case (pexpr_1 _pexprOconfig _pexprOfuncName _pexprOglobalDefinitions _pexprOinParentheses _pexprOisInModule _pexprOisMeta _pexprOisNegation _pexprOloopLevel _pexprOmtokenPos _pexprOregisterVarUse _pexprOscopeLevel _pexprOscopes _pexprOtopLevel _pexprOvarBeingDefined _pexprOvariableStyle) of+                                                { ( _pexprIglobalDefinitions,_pexprIidentifier,_pexprIisInModule,_pexprIisSimpleExpression,_pexprIisSingleVar,_pexprIscopes,_pexprIvariableStyle,_pexprIwarnings) ->+                                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _pexprIglobalDefinitions+                                                            {-# LINE 4035 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOglobalDefinitions ->+                                                     (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _pexprIidentifier+                                                             {-# LINE 4040 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOidentifier ->+                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _pexprIisInModule+                                                              {-# LINE 4045 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOisInModule ->+                                                       (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _pexprIisSimpleExpression+                                                               {-# LINE 4050 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOisSimpleExpression ->+                                                        (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _pexprIisSingleVar+                                                                {-# LINE 4055 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOisSingleVar ->+                                                         (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _pexprImtokenPos+                                                                 {-# LINE 4060 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOmtokenPos ->+                                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _pexprIscopes+                                                                  {-# LINE 4065 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOscopes ->+                                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _pexprIvariableStyle+                                                                   {-# LINE 4070 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _lhsOvariableStyle ->+                                                            (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _pexprIwarnings+                                                                    {-# LINE 4075 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _lhsOwarnings ->+                                                             ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Expr_APrefixExpr_1)) of+            { ( sem_Expr_1) ->+            ( _lhsOcopy,sem_Expr_1) }) }) }) })+sem_Expr_ATableConstructor :: T_FieldList ->+                              T_Expr+sem_Expr_ATableConstructor fields_ =+    (case (fields_) of+     { ( _fieldsIcopy,fields_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 ATableConstructor _fieldsIcopy+                 {-# LINE 4089 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 4094 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Expr_ATableConstructor_1 :: T_Expr_1+                       sem_Expr_ATableConstructor_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIinParentheses+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIisNegation+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsItopLevel+                              _lhsIvarBeingDefined+                              _lhsIvariableStyle ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 4115 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _fieldsOscopes ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 4120 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _fieldsOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 4125 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _fieldsOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 4130 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _fieldsOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 4135 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _fieldsOconfig ->+                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIvariableStyle+                                             {-# LINE 4140 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _fieldsOvariableStyle ->+                                      (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIscopeLevel+                                              {-# LINE 4145 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _fieldsOscopeLevel ->+                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsImtokenPos+                                               {-# LINE 4150 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _fieldsOmtokenPos ->+                                        (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIloopLevel+                                                {-# LINE 4155 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _fieldsOloopLevel ->+                                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIfuncName+                                                 {-# LINE 4160 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _fieldsOfuncName ->+                                          (case (({-# LINE 580 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  S.empty+                                                  {-# LINE 4165 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _fieldsOfieldNames ->+                                           (case (fields_1 _fieldsOconfig _fieldsOfieldNames _fieldsOfuncName _fieldsOglobalDefinitions _fieldsOisInModule _fieldsOisMeta _fieldsOloopLevel _fieldsOmtokenPos _fieldsOscopeLevel _fieldsOscopes _fieldsOvariableStyle) of+                                            { ( _fieldsIfieldNames,_fieldsIglobalDefinitions,_fieldsIidentifier,_fieldsIisInModule,_fieldsImtokenPos,_fieldsIscopes,_fieldsIvariableStyle,_fieldsIwarnings) ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _fieldsIglobalDefinitions+                                                        {-# LINE 4172 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOglobalDefinitions ->+                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _fieldsIidentifier+                                                         {-# LINE 4177 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOidentifier ->+                                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _fieldsIisInModule+                                                          {-# LINE 4182 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOisInModule ->+                                                   (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           True+                                                           {-# LINE 4187 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOisSimpleExpression ->+                                                    (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            Nothing+                                                            {-# LINE 4192 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOisSingleVar ->+                                                     (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _fieldsImtokenPos+                                                             {-# LINE 4197 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOmtokenPos ->+                                                      (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _fieldsIscopes+                                                              {-# LINE 4202 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOscopes ->+                                                       (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _fieldsIvariableStyle+                                                               {-# LINE 4207 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOvariableStyle ->+                                                        (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _fieldsIwarnings+                                                                {-# LINE 4212 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOwarnings ->+                                                         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Expr_ATableConstructor_1)) of+            { ( sem_Expr_1) ->+            ( _lhsOcopy,sem_Expr_1) }) }) }) })+sem_Expr_BinOpExpr :: T_BinOp ->+                      T_MExpr ->+                      T_MExpr ->+                      T_Expr+sem_Expr_BinOpExpr op_ left_ right_ =+    (case (right_) of+     { ( _rightIcopy,_rightImtokenPos,right_1) ->+         (case (left_) of+          { ( _leftIcopy,_leftImtokenPos,left_1) ->+              (case (op_) of+               { ( _opIcopy,op_1) ->+                   (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                           BinOpExpr _opIcopy _leftIcopy _rightIcopy+                           {-# LINE 4232 "src/GLuaFixer/AG/ASTLint.hs" #-}+                           )) of+                    { _copy ->+                    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                            _copy+                            {-# LINE 4237 "src/GLuaFixer/AG/ASTLint.hs" #-}+                            )) of+                     { _lhsOcopy ->+                     (case ((let sem_Expr_BinOpExpr_1 :: T_Expr_1+                                 sem_Expr_BinOpExpr_1 =+                                     (\ _lhsIconfig+                                        _lhsIfuncName+                                        _lhsIglobalDefinitions+                                        _lhsIinParentheses+                                        _lhsIisInModule+                                        _lhsIisMeta+                                        _lhsIisNegation+                                        _lhsIloopLevel+                                        _lhsImtokenPos+                                        _lhsIscopeLevel+                                        _lhsIscopes+                                        _lhsItopLevel+                                        _lhsIvarBeingDefined+                                        _lhsIvariableStyle ->+                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIscopes+                                                  {-# LINE 4258 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _opOscopes ->+                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIvariableStyle+                                                   {-# LINE 4263 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _opOvariableStyle ->+                                            (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIscopeLevel+                                                    {-# LINE 4268 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _opOscopeLevel ->+                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsImtokenPos+                                                     {-# LINE 4273 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _opOmtokenPos ->+                                              (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIloopLevel+                                                      {-# LINE 4278 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _opOloopLevel ->+                                               (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIisMeta+                                                       {-# LINE 4283 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _opOisMeta ->+                                                (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIisInModule+                                                        {-# LINE 4288 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _opOisInModule ->+                                                 (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsIglobalDefinitions+                                                         {-# LINE 4293 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _opOglobalDefinitions ->+                                                  (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIfuncName+                                                          {-# LINE 4298 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _opOfuncName ->+                                                   (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _lhsIconfig+                                                           {-# LINE 4303 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _opOconfig ->+                                                    (case (op_1 _opOconfig _opOfuncName _opOglobalDefinitions _opOisInModule _opOisMeta _opOloopLevel _opOmtokenPos _opOscopeLevel _opOscopes _opOvariableStyle) of+                                                     { ( _opIglobalDefinitions,_opIidentifier,_opIisInModule,_opImtokenPos,_opIscopes,_opIvariableStyle,_opIwarnings) ->+                                                         (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _opIscopes+                                                                 {-# LINE 4310 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _leftOscopes ->+                                                          (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIisMeta+                                                                  {-# LINE 4315 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _leftOisMeta ->+                                                           (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIconfig+                                                                   {-# LINE 4320 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _leftOconfig ->+                                                            (case (({-# LINE 586 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    Nothing+                                                                    {-# LINE 4325 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _leftOvarBeingDefined ->+                                                             (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _opIvariableStyle+                                                                     {-# LINE 4330 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _leftOvariableStyle ->+                                                              (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIscopeLevel+                                                                      {-# LINE 4335 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _leftOscopeLevel ->+                                                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _opImtokenPos+                                                                       {-# LINE 4340 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _leftOmtokenPos ->+                                                                (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _lhsIloopLevel+                                                                        {-# LINE 4345 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _leftOloopLevel ->+                                                                 (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _opIisInModule+                                                                         {-# LINE 4350 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _leftOisInModule ->+                                                                  (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _opIglobalDefinitions+                                                                          {-# LINE 4355 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _leftOglobalDefinitions ->+                                                                   (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           _lhsIfuncName+                                                                           {-# LINE 4360 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _leftOfuncName ->+                                                                    (case (({-# LINE 585 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            False+                                                                            {-# LINE 4365 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _leftOtopLevel ->+                                                                     (case (({-# LINE 584 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             False+                                                                             {-# LINE 4370 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _leftOinParentheses ->+                                                                      (case (({-# LINE 583 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              False+                                                                              {-# LINE 4375 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _leftOisNegation ->+                                                                       (case (left_1 _leftOconfig _leftOfuncName _leftOglobalDefinitions _leftOinParentheses _leftOisInModule _leftOisMeta _leftOisNegation _leftOloopLevel _leftOmtokenPos _leftOscopeLevel _leftOscopes _leftOtopLevel _leftOvarBeingDefined _leftOvariableStyle) of+                                                                        { ( _leftIglobalDefinitions,_leftIidentifier,_leftIisInModule,_leftIisSimpleExpression,_leftIisSingleVar,_leftIscopes,_leftIvariableStyle,_leftIwarnings) ->+                                                                            (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _leftIscopes+                                                                                    {-# LINE 4382 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _rightOscopes ->+                                                                             (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _lhsIisMeta+                                                                                     {-# LINE 4387 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _rightOisMeta ->+                                                                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _leftIisInModule+                                                                                      {-# LINE 4392 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _rightOisInModule ->+                                                                               (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _leftIglobalDefinitions+                                                                                       {-# LINE 4397 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _rightOglobalDefinitions ->+                                                                                (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        _lhsIconfig+                                                                                        {-# LINE 4402 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _rightOconfig ->+                                                                                 (case (({-# LINE 590 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         Nothing+                                                                                         {-# LINE 4407 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _rightOvarBeingDefined ->+                                                                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                          _leftIvariableStyle+                                                                                          {-# LINE 4412 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                          )) of+                                                                                   { _rightOvariableStyle ->+                                                                                   (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                           _lhsIscopeLevel+                                                                                           {-# LINE 4417 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                           )) of+                                                                                    { _rightOscopeLevel ->+                                                                                    (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                            _leftImtokenPos+                                                                                            {-# LINE 4422 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                            )) of+                                                                                     { _rightOmtokenPos ->+                                                                                     (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                             _lhsIloopLevel+                                                                                             {-# LINE 4427 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                             )) of+                                                                                      { _rightOloopLevel ->+                                                                                      (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                              _lhsIfuncName+                                                                                              {-# LINE 4432 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                              )) of+                                                                                       { _rightOfuncName ->+                                                                                       (case (({-# LINE 589 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                               False+                                                                                               {-# LINE 4437 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                               )) of+                                                                                        { _rightOtopLevel ->+                                                                                        (case (({-# LINE 588 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                False+                                                                                                {-# LINE 4442 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                )) of+                                                                                         { _rightOinParentheses ->+                                                                                         (case (({-# LINE 587 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                 False+                                                                                                 {-# LINE 4447 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                 )) of+                                                                                          { _rightOisNegation ->+                                                                                          (case (right_1 _rightOconfig _rightOfuncName _rightOglobalDefinitions _rightOinParentheses _rightOisInModule _rightOisMeta _rightOisNegation _rightOloopLevel _rightOmtokenPos _rightOscopeLevel _rightOscopes _rightOtopLevel _rightOvarBeingDefined _rightOvariableStyle) of+                                                                                           { ( _rightIglobalDefinitions,_rightIidentifier,_rightIisInModule,_rightIisSimpleExpression,_rightIisSingleVar,_rightIscopes,_rightIvariableStyle,_rightIwarnings) ->+                                                                                               (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                       _rightIglobalDefinitions+                                                                                                       {-# LINE 4454 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                       )) of+                                                                                                { _lhsOglobalDefinitions ->+                                                                                                (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                        (const _opIidentifier (const _leftIidentifier _rightIidentifier))+                                                                                                        {-# LINE 4459 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                        )) of+                                                                                                 { _lhsOidentifier ->+                                                                                                 (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                         _rightIisInModule+                                                                                                         {-# LINE 4464 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                         )) of+                                                                                                  { _lhsOisInModule ->+                                                                                                  (case (({-# LINE 582 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                          False+                                                                                                          {-# LINE 4469 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                          )) of+                                                                                                   { _lhsOisSimpleExpression ->+                                                                                                   (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                           (const (const Nothing) _leftIisSingleVar _rightIisSingleVar)+                                                                                                           {-# LINE 4474 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                           )) of+                                                                                                    { _lhsOisSingleVar ->+                                                                                                    (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                            _rightImtokenPos+                                                                                                            {-# LINE 4479 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                            )) of+                                                                                                     { _lhsOmtokenPos ->+                                                                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                             _rightIscopes+                                                                                                             {-# LINE 4484 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                             )) of+                                                                                                      { _lhsOscopes ->+                                                                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                              _rightIvariableStyle+                                                                                                              {-# LINE 4489 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                              )) of+                                                                                                       { _lhsOvariableStyle ->+                                                                                                       (case (({-# LINE 594 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                               _opIwarnings ++ _leftIwarnings ++ _rightIwarnings+                                                                                                               {-# LINE 4494 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                               )) of+                                                                                                        { _warnings_augmented_syn ->+                                                                                                        (case (({-# LINE 593 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                oppositeBinOp _opIcopy+                                                                                                                {-# LINE 4499 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                )) of+                                                                                                         { _stupidNegation ->+                                                                                                         (case (({-# LINE 594 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                 if not (lint_doubleNegations _lhsIconfig) || not _lhsIisNegation || isNothing _stupidNegation     then id else+                                                                                                                   (:) $ warn _lhsImtokenPos $ SillyNegation$ fromMaybe (error "fromMaybe sem Expr loc.stupidNegation") _stupidNegation+                                                                                                                 {-# LINE 4505 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                 )) of+                                                                                                          { _warnings_augmented_f1 ->+                                                                                                          (case (({-# LINE 594 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                  foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                                                                  {-# LINE 4510 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                  )) of+                                                                                                           { _lhsOwarnings ->+                                                                                                           ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                             in  sem_Expr_BinOpExpr_1)) of+                      { ( sem_Expr_1) ->+                      ( _lhsOcopy,sem_Expr_1) }) }) }) }) }) })+sem_Expr_UnOpExpr :: T_UnOp ->+                     T_MExpr ->+                     T_Expr+sem_Expr_UnOpExpr op_ right_ =+    (case (right_) of+     { ( _rightIcopy,_rightImtokenPos,right_1) ->+         (case (op_) of+          { ( _opIcopy,op_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      UnOpExpr _opIcopy _rightIcopy+                      {-# LINE 4527 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 4532 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Expr_UnOpExpr_1 :: T_Expr_1+                            sem_Expr_UnOpExpr_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIinParentheses+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIisNegation+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsItopLevel+                                   _lhsIvarBeingDefined+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 4553 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _opOscopes ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 4558 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _opOvariableStyle ->+                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopeLevel+                                               {-# LINE 4563 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _opOscopeLevel ->+                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsImtokenPos+                                                {-# LINE 4568 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _opOmtokenPos ->+                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIloopLevel+                                                 {-# LINE 4573 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _opOloopLevel ->+                                          (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIisMeta+                                                  {-# LINE 4578 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _opOisMeta ->+                                           (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIisInModule+                                                   {-# LINE 4583 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _opOisInModule ->+                                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIglobalDefinitions+                                                    {-# LINE 4588 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _opOglobalDefinitions ->+                                             (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIfuncName+                                                     {-# LINE 4593 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _opOfuncName ->+                                              (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIconfig+                                                      {-# LINE 4598 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _opOconfig ->+                                               (case (op_1 _opOconfig _opOfuncName _opOglobalDefinitions _opOisInModule _opOisMeta _opOloopLevel _opOmtokenPos _opOscopeLevel _opOscopes _opOvariableStyle) of+                                                { ( _opIglobalDefinitions,_opIidentifier,_opIisInModule,_opIisNegation,_opImtokenPos,_opIscopes,_opIvariableStyle,_opIwarnings) ->+                                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _opIscopes+                                                            {-# LINE 4605 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _rightOscopes ->+                                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _lhsIisMeta+                                                             {-# LINE 4610 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _rightOisMeta ->+                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _opIisInModule+                                                              {-# LINE 4615 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _rightOisInModule ->+                                                       (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _opIglobalDefinitions+                                                               {-# LINE 4620 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _rightOglobalDefinitions ->+                                                        (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _lhsIconfig+                                                                {-# LINE 4625 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _rightOconfig ->+                                                         (case (({-# LINE 601 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 Nothing+                                                                 {-# LINE 4630 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _rightOvarBeingDefined ->+                                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _opIvariableStyle+                                                                  {-# LINE 4635 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _rightOvariableStyle ->+                                                           (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIscopeLevel+                                                                   {-# LINE 4640 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _rightOscopeLevel ->+                                                            (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _opImtokenPos+                                                                    {-# LINE 4645 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _rightOmtokenPos ->+                                                             (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _lhsIloopLevel+                                                                     {-# LINE 4650 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _rightOloopLevel ->+                                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIfuncName+                                                                      {-# LINE 4655 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _rightOfuncName ->+                                                               (case (({-# LINE 600 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       False+                                                                       {-# LINE 4660 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _rightOtopLevel ->+                                                                (case (({-# LINE 599 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        False+                                                                        {-# LINE 4665 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _rightOinParentheses ->+                                                                 (case (({-# LINE 598 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _opIisNegation+                                                                         {-# LINE 4670 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _rightOisNegation ->+                                                                  (case (right_1 _rightOconfig _rightOfuncName _rightOglobalDefinitions _rightOinParentheses _rightOisInModule _rightOisMeta _rightOisNegation _rightOloopLevel _rightOmtokenPos _rightOscopeLevel _rightOscopes _rightOtopLevel _rightOvarBeingDefined _rightOvariableStyle) of+                                                                   { ( _rightIglobalDefinitions,_rightIidentifier,_rightIisInModule,_rightIisSimpleExpression,_rightIisSingleVar,_rightIscopes,_rightIvariableStyle,_rightIwarnings) ->+                                                                       (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _rightIglobalDefinitions+                                                                               {-# LINE 4677 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOglobalDefinitions ->+                                                                        (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                (const _opIidentifier _rightIidentifier)+                                                                                {-# LINE 4682 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOidentifier ->+                                                                         (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _rightIisInModule+                                                                                 {-# LINE 4687 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOisInModule ->+                                                                          (case (({-# LINE 597 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  False+                                                                                  {-# LINE 4692 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOisSimpleExpression ->+                                                                           (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _rightIisSingleVar+                                                                                   {-# LINE 4697 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOisSingleVar ->+                                                                            (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _rightImtokenPos+                                                                                    {-# LINE 4702 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOmtokenPos ->+                                                                             (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _rightIscopes+                                                                                     {-# LINE 4707 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOscopes ->+                                                                              (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _rightIvariableStyle+                                                                                      {-# LINE 4712 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOvariableStyle ->+                                                                               (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _opIwarnings ++ _rightIwarnings+                                                                                       {-# LINE 4717 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _lhsOwarnings ->+                                                                                ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Expr_UnOpExpr_1)) of+                 { ( sem_Expr_1) ->+                 ( _lhsOcopy,sem_Expr_1) }) }) }) }) })+-- ExprSuffixList ----------------------------------------------+-- cata+sem_ExprSuffixList :: ExprSuffixList ->+                      T_ExprSuffixList+sem_ExprSuffixList list =+    (Prelude.foldr sem_ExprSuffixList_Cons sem_ExprSuffixList_Nil (Prelude.map sem_PFExprSuffix list))+-- semantic domain+type T_ExprSuffixList = ( ExprSuffixList,T_ExprSuffixList_1)+type T_ExprSuffixList_1 = LintSettings ->+                          String ->+                          (M.Map String [Region]) ->+                          Bool ->+                          Bool ->+                          Int ->+                          Region ->+                          Int ->+                          ([M.Map String (Bool, Region)]) ->+                          DeterminedVariableStyle ->+                          ( (M.Map String [Region]),String,Bool,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_ExprSuffixList = Inh_ExprSuffixList {config_Inh_ExprSuffixList :: LintSettings,funcName_Inh_ExprSuffixList :: String,globalDefinitions_Inh_ExprSuffixList :: (M.Map String [Region]),isInModule_Inh_ExprSuffixList :: Bool,isMeta_Inh_ExprSuffixList :: Bool,loopLevel_Inh_ExprSuffixList :: Int,mtokenPos_Inh_ExprSuffixList :: Region,scopeLevel_Inh_ExprSuffixList :: Int,scopes_Inh_ExprSuffixList :: ([M.Map String (Bool, Region)]),variableStyle_Inh_ExprSuffixList :: DeterminedVariableStyle}+data Syn_ExprSuffixList = Syn_ExprSuffixList {copy_Syn_ExprSuffixList :: ExprSuffixList,globalDefinitions_Syn_ExprSuffixList :: (M.Map String [Region]),identifier_Syn_ExprSuffixList :: String,isInModule_Syn_ExprSuffixList :: Bool,isSimpleExpression_Syn_ExprSuffixList :: Bool,mtokenPos_Syn_ExprSuffixList :: Region,scopes_Syn_ExprSuffixList :: ([M.Map String (Bool, Region)]),variableStyle_Syn_ExprSuffixList :: DeterminedVariableStyle,warnings_Syn_ExprSuffixList :: ([String -> LintMessage])}+wrap_ExprSuffixList :: T_ExprSuffixList ->+                       Inh_ExprSuffixList ->+                       Syn_ExprSuffixList+wrap_ExprSuffixList sem (Inh_ExprSuffixList _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_ExprSuffixList _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOisSimpleExpression _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_ExprSuffixList_Cons :: T_PFExprSuffix ->+                           T_ExprSuffixList ->+                           T_ExprSuffixList+sem_ExprSuffixList_Cons hd_ tl_ =+    (case (tl_) of+     { ( _tlIcopy,tl_1) ->+         (case (hd_) of+          { ( _hdIcopy,hd_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (:) _hdIcopy _tlIcopy+                      {-# LINE 4762 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 4767 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_ExprSuffixList_Cons_1 :: T_ExprSuffixList_1+                            sem_ExprSuffixList_Cons_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 4784 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _hdOscopes ->+                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisMeta+                                              {-# LINE 4789 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _hdOisMeta ->+                                       (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIconfig+                                               {-# LINE 4794 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _hdOconfig ->+                                        (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIvariableStyle+                                                {-# LINE 4799 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _hdOvariableStyle ->+                                         (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIscopeLevel+                                                 {-# LINE 4804 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _hdOscopeLevel ->+                                          (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsImtokenPos+                                                  {-# LINE 4809 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _hdOmtokenPos ->+                                           (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIloopLevel+                                                   {-# LINE 4814 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _hdOloopLevel ->+                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisInModule+                                                    {-# LINE 4819 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _hdOisInModule ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 4824 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _hdOglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 4829 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _hdOfuncName ->+                                               (case (hd_1 _hdOconfig _hdOfuncName _hdOglobalDefinitions _hdOisInModule _hdOisMeta _hdOloopLevel _hdOmtokenPos _hdOscopeLevel _hdOscopes _hdOvariableStyle) of+                                                { ( _hdIglobalDefinitions,_hdIidentifier,_hdIisInModule,_hdIisSimpleExpression,_hdImtokenPos,_hdIscopes,_hdIvariableStyle,_hdIwarnings) ->+                                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _hdIscopes+                                                            {-# LINE 4836 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _tlOscopes ->+                                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _lhsIisMeta+                                                             {-# LINE 4841 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _tlOisMeta ->+                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _hdIisInModule+                                                              {-# LINE 4846 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _tlOisInModule ->+                                                       (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _hdIglobalDefinitions+                                                               {-# LINE 4851 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _tlOglobalDefinitions ->+                                                        (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _lhsIconfig+                                                                {-# LINE 4856 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _tlOconfig ->+                                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _hdIvariableStyle+                                                                 {-# LINE 4861 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _tlOvariableStyle ->+                                                          (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIscopeLevel+                                                                  {-# LINE 4866 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _tlOscopeLevel ->+                                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _hdImtokenPos+                                                                   {-# LINE 4871 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _tlOmtokenPos ->+                                                            (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIloopLevel+                                                                    {-# LINE 4876 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _tlOloopLevel ->+                                                             (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _lhsIfuncName+                                                                     {-# LINE 4881 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _tlOfuncName ->+                                                              (case (tl_1 _tlOconfig _tlOfuncName _tlOglobalDefinitions _tlOisInModule _tlOisMeta _tlOloopLevel _tlOmtokenPos _tlOscopeLevel _tlOscopes _tlOvariableStyle) of+                                                               { ( _tlIglobalDefinitions,_tlIidentifier,_tlIisInModule,_tlIisSimpleExpression,_tlImtokenPos,_tlIscopes,_tlIvariableStyle,_tlIwarnings) ->+                                                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           _tlIglobalDefinitions+                                                                           {-# LINE 4888 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _lhsOglobalDefinitions ->+                                                                    (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            (const _hdIidentifier _tlIidentifier)+                                                                            {-# LINE 4893 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _lhsOidentifier ->+                                                                     (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _tlIisInModule+                                                                             {-# LINE 4898 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _lhsOisInModule ->+                                                                      (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _hdIisSimpleExpression && _tlIisSimpleExpression+                                                                              {-# LINE 4903 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _lhsOisSimpleExpression ->+                                                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _tlImtokenPos+                                                                               {-# LINE 4908 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOmtokenPos ->+                                                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _tlIscopes+                                                                                {-# LINE 4913 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOscopes ->+                                                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _tlIvariableStyle+                                                                                 {-# LINE 4918 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOvariableStyle ->+                                                                          (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _hdIwarnings ++ _tlIwarnings+                                                                                  {-# LINE 4923 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOwarnings ->+                                                                           ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_ExprSuffixList_Cons_1)) of+                 { ( sem_ExprSuffixList_1) ->+                 ( _lhsOcopy,sem_ExprSuffixList_1) }) }) }) }) })+sem_ExprSuffixList_Nil :: T_ExprSuffixList+sem_ExprSuffixList_Nil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            []+            {-# LINE 4934 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 4939 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_ExprSuffixList_Nil_1 :: T_ExprSuffixList_1+                  sem_ExprSuffixList_Nil_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 4956 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 4961 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 4966 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      True+                                      {-# LINE 4971 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisSimpleExpression ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 4976 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 4981 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 4986 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 4991 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_ExprSuffixList_Nil_1)) of+       { ( sem_ExprSuffixList_1) ->+       ( _lhsOcopy,sem_ExprSuffixList_1) }) }) })+-- Field -------------------------------------------------------+-- cata+sem_Field :: Field ->+             T_Field+sem_Field (ExprField _key _value _sep) =+    (sem_Field_ExprField (sem_MExpr _key) (sem_MExpr _value) (sem_FieldSep _sep))+sem_Field (NamedField _key _value _sep) =+    (sem_Field_NamedField (sem_MToken _key) (sem_MExpr _value) (sem_FieldSep _sep))+sem_Field (UnnamedField _value _sep) =+    (sem_Field_UnnamedField (sem_MExpr _value) (sem_FieldSep _sep))+-- semantic domain+type T_Field = ( Field,T_Field_1)+type T_Field_1 = LintSettings ->+                 (S.Set Token) ->+                 String ->+                 (M.Map String [Region]) ->+                 Bool ->+                 Bool ->+                 Int ->+                 Region ->+                 Int ->+                 ([M.Map String (Bool, Region)]) ->+                 DeterminedVariableStyle ->+                 ( (S.Set Token),(M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_Field = Inh_Field {config_Inh_Field :: LintSettings,fieldNames_Inh_Field :: (S.Set Token),funcName_Inh_Field :: String,globalDefinitions_Inh_Field :: (M.Map String [Region]),isInModule_Inh_Field :: Bool,isMeta_Inh_Field :: Bool,loopLevel_Inh_Field :: Int,mtokenPos_Inh_Field :: Region,scopeLevel_Inh_Field :: Int,scopes_Inh_Field :: ([M.Map String (Bool, Region)]),variableStyle_Inh_Field :: DeterminedVariableStyle}+data Syn_Field = Syn_Field {copy_Syn_Field :: Field,fieldNames_Syn_Field :: (S.Set Token),globalDefinitions_Syn_Field :: (M.Map String [Region]),identifier_Syn_Field :: String,isInModule_Syn_Field :: Bool,mtokenPos_Syn_Field :: Region,scopes_Syn_Field :: ([M.Map String (Bool, Region)]),variableStyle_Syn_Field :: DeterminedVariableStyle,warnings_Syn_Field :: ([String -> LintMessage])}+wrap_Field :: T_Field ->+              Inh_Field ->+              Syn_Field+wrap_Field sem (Inh_Field _lhsIconfig _lhsIfieldNames _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOfieldNames,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfieldNames _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_Field _lhsOcopy _lhsOfieldNames _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_Field_ExprField :: T_MExpr ->+                       T_MExpr ->+                       T_FieldSep ->+                       T_Field+sem_Field_ExprField key_ value_ sep_ =+    (case (sep_) of+     { ( _sepIcopy,sep_1) ->+         (case (value_) of+          { ( _valueIcopy,_valueImtokenPos,value_1) ->+              (case (key_) of+               { ( _keyIcopy,_keyImtokenPos,key_1) ->+                   (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                           ExprField _keyIcopy _valueIcopy _sepIcopy+                           {-# LINE 5044 "src/GLuaFixer/AG/ASTLint.hs" #-}+                           )) of+                    { _copy ->+                    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                            _copy+                            {-# LINE 5049 "src/GLuaFixer/AG/ASTLint.hs" #-}+                            )) of+                     { _lhsOcopy ->+                     (case ((let sem_Field_ExprField_1 :: T_Field_1+                                 sem_Field_ExprField_1 =+                                     (\ _lhsIconfig+                                        _lhsIfieldNames+                                        _lhsIfuncName+                                        _lhsIglobalDefinitions+                                        _lhsIisInModule+                                        _lhsIisMeta+                                        _lhsIloopLevel+                                        _lhsImtokenPos+                                        _lhsIscopeLevel+                                        _lhsIscopes+                                        _lhsIvariableStyle ->+                                          (case (({-# LINE 163 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIfieldNames+                                                  {-# LINE 5067 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _lhsOfieldNames ->+                                           (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIscopes+                                                   {-# LINE 5072 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _keyOscopes ->+                                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisMeta+                                                    {-# LINE 5077 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _keyOisMeta ->+                                             (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIconfig+                                                     {-# LINE 5082 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _keyOconfig ->+                                              (case (({-# LINE 617 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      Nothing+                                                      {-# LINE 5087 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _keyOvarBeingDefined ->+                                               (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIvariableStyle+                                                       {-# LINE 5092 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _keyOvariableStyle ->+                                                (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIscopeLevel+                                                        {-# LINE 5097 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _keyOscopeLevel ->+                                                 (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsImtokenPos+                                                         {-# LINE 5102 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _keyOmtokenPos ->+                                                  (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIloopLevel+                                                          {-# LINE 5107 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _keyOloopLevel ->+                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _lhsIisInModule+                                                           {-# LINE 5112 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _keyOisInModule ->+                                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _lhsIglobalDefinitions+                                                            {-# LINE 5117 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _keyOglobalDefinitions ->+                                                     (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _lhsIfuncName+                                                             {-# LINE 5122 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _keyOfuncName ->+                                                      (case (({-# LINE 616 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              True+                                                              {-# LINE 5127 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _keyOtopLevel ->+                                                       (case (({-# LINE 615 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               True+                                                               {-# LINE 5132 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _keyOinParentheses ->+                                                        (case (({-# LINE 614 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                False+                                                                {-# LINE 5137 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _keyOisNegation ->+                                                         (case (key_1 _keyOconfig _keyOfuncName _keyOglobalDefinitions _keyOinParentheses _keyOisInModule _keyOisMeta _keyOisNegation _keyOloopLevel _keyOmtokenPos _keyOscopeLevel _keyOscopes _keyOtopLevel _keyOvarBeingDefined _keyOvariableStyle) of+                                                          { ( _keyIglobalDefinitions,_keyIidentifier,_keyIisInModule,_keyIisSimpleExpression,_keyIisSingleVar,_keyIscopes,_keyIvariableStyle,_keyIwarnings) ->+                                                              (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _keyIscopes+                                                                      {-# LINE 5144 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _valueOscopes ->+                                                               (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIisMeta+                                                                       {-# LINE 5149 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _valueOisMeta ->+                                                                (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _keyIisInModule+                                                                        {-# LINE 5154 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _valueOisInModule ->+                                                                 (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _keyIglobalDefinitions+                                                                         {-# LINE 5159 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _valueOglobalDefinitions ->+                                                                  (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _lhsIconfig+                                                                          {-# LINE 5164 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _valueOconfig ->+                                                                   (case (({-# LINE 621 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           Nothing+                                                                           {-# LINE 5169 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _valueOvarBeingDefined ->+                                                                    (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            _keyIvariableStyle+                                                                            {-# LINE 5174 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _valueOvariableStyle ->+                                                                     (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _lhsIscopeLevel+                                                                             {-# LINE 5179 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _valueOscopeLevel ->+                                                                      (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _keyImtokenPos+                                                                              {-# LINE 5184 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _valueOmtokenPos ->+                                                                       (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _lhsIloopLevel+                                                                               {-# LINE 5189 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _valueOloopLevel ->+                                                                        (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _lhsIfuncName+                                                                                {-# LINE 5194 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _valueOfuncName ->+                                                                         (case (({-# LINE 620 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 True+                                                                                 {-# LINE 5199 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _valueOtopLevel ->+                                                                          (case (({-# LINE 619 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  True+                                                                                  {-# LINE 5204 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _valueOinParentheses ->+                                                                           (case (({-# LINE 618 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   False+                                                                                   {-# LINE 5209 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _valueOisNegation ->+                                                                            (case (value_1 _valueOconfig _valueOfuncName _valueOglobalDefinitions _valueOinParentheses _valueOisInModule _valueOisMeta _valueOisNegation _valueOloopLevel _valueOmtokenPos _valueOscopeLevel _valueOscopes _valueOtopLevel _valueOvarBeingDefined _valueOvariableStyle) of+                                                                             { ( _valueIglobalDefinitions,_valueIidentifier,_valueIisInModule,_valueIisSimpleExpression,_valueIisSingleVar,_valueIscopes,_valueIvariableStyle,_valueIwarnings) ->+                                                                                 (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         _valueIglobalDefinitions+                                                                                         {-# LINE 5216 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _sepOglobalDefinitions ->+                                                                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                          _valueIvariableStyle+                                                                                          {-# LINE 5221 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                          )) of+                                                                                   { _sepOvariableStyle ->+                                                                                   (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                           _valueIscopes+                                                                                           {-# LINE 5226 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                           )) of+                                                                                    { _sepOscopes ->+                                                                                    (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                            _lhsIscopeLevel+                                                                                            {-# LINE 5231 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                            )) of+                                                                                     { _sepOscopeLevel ->+                                                                                     (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                             _valueImtokenPos+                                                                                             {-# LINE 5236 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                             )) of+                                                                                      { _sepOmtokenPos ->+                                                                                      (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                              _lhsIloopLevel+                                                                                              {-# LINE 5241 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                              )) of+                                                                                       { _sepOloopLevel ->+                                                                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                               _lhsIisMeta+                                                                                               {-# LINE 5246 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                               )) of+                                                                                        { _sepOisMeta ->+                                                                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                _valueIisInModule+                                                                                                {-# LINE 5251 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                )) of+                                                                                         { _sepOisInModule ->+                                                                                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                 _lhsIfuncName+                                                                                                 {-# LINE 5256 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                 )) of+                                                                                          { _sepOfuncName ->+                                                                                          (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                  _lhsIconfig+                                                                                                  {-# LINE 5261 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                  )) of+                                                                                           { _sepOconfig ->+                                                                                           (case (sep_1 _sepOconfig _sepOfuncName _sepOglobalDefinitions _sepOisInModule _sepOisMeta _sepOloopLevel _sepOmtokenPos _sepOscopeLevel _sepOscopes _sepOvariableStyle) of+                                                                                            { ( _sepIglobalDefinitions,_sepIidentifier,_sepIisInModule,_sepImtokenPos,_sepIscopes,_sepIvariableStyle,_sepIwarnings) ->+                                                                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                        _sepIglobalDefinitions+                                                                                                        {-# LINE 5268 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                        )) of+                                                                                                 { _lhsOglobalDefinitions ->+                                                                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                         (const _keyIidentifier (const _valueIidentifier _sepIidentifier))+                                                                                                         {-# LINE 5273 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                         )) of+                                                                                                  { _lhsOidentifier ->+                                                                                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                          _sepIisInModule+                                                                                                          {-# LINE 5278 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                          )) of+                                                                                                   { _lhsOisInModule ->+                                                                                                   (case (({-# LINE 613 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                           _keyImtokenPos+                                                                                                           {-# LINE 5283 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                           )) of+                                                                                                    { _lhsOmtokenPos ->+                                                                                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                            _sepIscopes+                                                                                                            {-# LINE 5288 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                            )) of+                                                                                                     { _lhsOscopes ->+                                                                                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                             _sepIvariableStyle+                                                                                                             {-# LINE 5293 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                             )) of+                                                                                                      { _lhsOvariableStyle ->+                                                                                                      (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                              _keyIwarnings ++ _valueIwarnings ++ _sepIwarnings+                                                                                                              {-# LINE 5298 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                              )) of+                                                                                                       { _lhsOwarnings ->+                                                                                                       ( _lhsOfieldNames,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                             in  sem_Field_ExprField_1)) of+                      { ( sem_Field_1) ->+                      ( _lhsOcopy,sem_Field_1) }) }) }) }) }) })+sem_Field_NamedField :: T_MToken ->+                        T_MExpr ->+                        T_FieldSep ->+                        T_Field+sem_Field_NamedField key_ value_ sep_ =+    (case (sep_) of+     { ( _sepIcopy,sep_1) ->+         (case (value_) of+          { ( _valueIcopy,_valueImtokenPos,value_1) ->+              (case (key_) of+               { ( _keyIcopy,_keyImtok,_keyImtokenPos,key_1) ->+                   (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                           NamedField _keyIcopy _valueIcopy _sepIcopy+                           {-# LINE 5318 "src/GLuaFixer/AG/ASTLint.hs" #-}+                           )) of+                    { _copy ->+                    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                            _copy+                            {-# LINE 5323 "src/GLuaFixer/AG/ASTLint.hs" #-}+                            )) of+                     { _lhsOcopy ->+                     (case ((let sem_Field_NamedField_1 :: T_Field_1+                                 sem_Field_NamedField_1 =+                                     (\ _lhsIconfig+                                        _lhsIfieldNames+                                        _lhsIfuncName+                                        _lhsIglobalDefinitions+                                        _lhsIisInModule+                                        _lhsIisMeta+                                        _lhsIloopLevel+                                        _lhsImtokenPos+                                        _lhsIscopeLevel+                                        _lhsIscopes+                                        _lhsIvariableStyle ->+                                          (case (({-# LINE 624 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  S.insert _keyImtok _lhsIfieldNames+                                                  {-# LINE 5341 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _lhsOfieldNames ->+                                           (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIscopes+                                                   {-# LINE 5346 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _keyOscopes ->+                                            (case (({-# LINE 623 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _keyImtokenPos+                                                    {-# LINE 5351 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _mtokenPos ->+                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _mtokenPos+                                                     {-# LINE 5356 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _keyOmtokenPos ->+                                              (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIisMeta+                                                      {-# LINE 5361 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _keyOisMeta ->+                                               (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIisInModule+                                                       {-# LINE 5366 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _keyOisInModule ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIglobalDefinitions+                                                        {-# LINE 5371 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _keyOglobalDefinitions ->+                                                 (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsIfuncName+                                                         {-# LINE 5376 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _keyOfuncName ->+                                                  (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIconfig+                                                          {-# LINE 5381 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _keyOconfig ->+                                                   (case (key_1 _keyOconfig _keyOfuncName _keyOglobalDefinitions _keyOisInModule _keyOisMeta _keyOmtokenPos _keyOscopes) of+                                                    { ( _keyIglobalDefinitions,_keyIidentifier,_keyIisInModule,_keyIscopes,_keyIwarnings) ->+                                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _keyIscopes+                                                                {-# LINE 5388 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _valueOscopes ->+                                                         (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _lhsIisMeta+                                                                 {-# LINE 5393 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _valueOisMeta ->+                                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _keyIisInModule+                                                                  {-# LINE 5398 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _valueOisInModule ->+                                                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _keyIglobalDefinitions+                                                                   {-# LINE 5403 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _valueOglobalDefinitions ->+                                                            (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIconfig+                                                                    {-# LINE 5408 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _valueOconfig ->+                                                             (case (({-# LINE 625 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     Nothing+                                                                     {-# LINE 5413 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _valueOvarBeingDefined ->+                                                              (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIvariableStyle+                                                                      {-# LINE 5418 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _valueOvariableStyle ->+                                                               (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIscopeLevel+                                                                       {-# LINE 5423 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _valueOscopeLevel ->+                                                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _mtokenPos+                                                                        {-# LINE 5428 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _valueOmtokenPos ->+                                                                 (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _lhsIloopLevel+                                                                         {-# LINE 5433 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _valueOloopLevel ->+                                                                  (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _lhsIfuncName+                                                                          {-# LINE 5438 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _valueOfuncName ->+                                                                   (case (({-# LINE 628 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           True+                                                                           {-# LINE 5443 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _valueOtopLevel ->+                                                                    (case (({-# LINE 627 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            True+                                                                            {-# LINE 5448 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _valueOinParentheses ->+                                                                     (case (({-# LINE 626 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             False+                                                                             {-# LINE 5453 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _valueOisNegation ->+                                                                      (case (value_1 _valueOconfig _valueOfuncName _valueOglobalDefinitions _valueOinParentheses _valueOisInModule _valueOisMeta _valueOisNegation _valueOloopLevel _valueOmtokenPos _valueOscopeLevel _valueOscopes _valueOtopLevel _valueOvarBeingDefined _valueOvariableStyle) of+                                                                       { ( _valueIglobalDefinitions,_valueIidentifier,_valueIisInModule,_valueIisSimpleExpression,_valueIisSingleVar,_valueIscopes,_valueIvariableStyle,_valueIwarnings) ->+                                                                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _valueIglobalDefinitions+                                                                                   {-# LINE 5460 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _sepOglobalDefinitions ->+                                                                            (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _valueIvariableStyle+                                                                                    {-# LINE 5465 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _sepOvariableStyle ->+                                                                             (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _valueIscopes+                                                                                     {-# LINE 5470 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _sepOscopes ->+                                                                              (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _lhsIscopeLevel+                                                                                      {-# LINE 5475 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _sepOscopeLevel ->+                                                                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _mtokenPos+                                                                                       {-# LINE 5480 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _sepOmtokenPos ->+                                                                                (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        _lhsIloopLevel+                                                                                        {-# LINE 5485 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _sepOloopLevel ->+                                                                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         _lhsIisMeta+                                                                                         {-# LINE 5490 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _sepOisMeta ->+                                                                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                          _valueIisInModule+                                                                                          {-# LINE 5495 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                          )) of+                                                                                   { _sepOisInModule ->+                                                                                   (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                           _lhsIfuncName+                                                                                           {-# LINE 5500 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                           )) of+                                                                                    { _sepOfuncName ->+                                                                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                            _lhsIconfig+                                                                                            {-# LINE 5505 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                            )) of+                                                                                     { _sepOconfig ->+                                                                                     (case (sep_1 _sepOconfig _sepOfuncName _sepOglobalDefinitions _sepOisInModule _sepOisMeta _sepOloopLevel _sepOmtokenPos _sepOscopeLevel _sepOscopes _sepOvariableStyle) of+                                                                                      { ( _sepIglobalDefinitions,_sepIidentifier,_sepIisInModule,_sepImtokenPos,_sepIscopes,_sepIvariableStyle,_sepIwarnings) ->+                                                                                          (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                  _sepIglobalDefinitions+                                                                                                  {-# LINE 5512 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                  )) of+                                                                                           { _lhsOglobalDefinitions ->+                                                                                           (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                   (const _keyIidentifier (const _valueIidentifier _sepIidentifier))+                                                                                                   {-# LINE 5517 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                   )) of+                                                                                            { _lhsOidentifier ->+                                                                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                    _sepIisInModule+                                                                                                    {-# LINE 5522 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                    )) of+                                                                                             { _lhsOisInModule ->+                                                                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                     _mtokenPos+                                                                                                     {-# LINE 5527 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                     )) of+                                                                                              { _lhsOmtokenPos ->+                                                                                              (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                      _sepIscopes+                                                                                                      {-# LINE 5532 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                      )) of+                                                                                               { _lhsOscopes ->+                                                                                               (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                       _sepIvariableStyle+                                                                                                       {-# LINE 5537 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                       )) of+                                                                                                { _lhsOvariableStyle ->+                                                                                                (case (({-# LINE 629 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                        _keyIwarnings ++ _valueIwarnings ++ _sepIwarnings+                                                                                                        {-# LINE 5542 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                        )) of+                                                                                                 { _warnings_augmented_syn ->+                                                                                                 (case (({-# LINE 629 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                         if not (lint_duplicateTableKeys _lhsIconfig) || not (S.member _keyImtok _lhsIfieldNames) then id else+                                                                                                           (:) $ warn _keyImtokenPos $ DuplicateKeyInTable _keyImtok+                                                                                                         {-# LINE 5548 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                         )) of+                                                                                                  { _warnings_augmented_f1 ->+                                                                                                  (case (({-# LINE 629 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                          foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                                                          {-# LINE 5553 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                          )) of+                                                                                                   { _lhsOwarnings ->+                                                                                                   ( _lhsOfieldNames,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                             in  sem_Field_NamedField_1)) of+                      { ( sem_Field_1) ->+                      ( _lhsOcopy,sem_Field_1) }) }) }) }) }) })+sem_Field_UnnamedField :: T_MExpr ->+                          T_FieldSep ->+                          T_Field+sem_Field_UnnamedField value_ sep_ =+    (case (sep_) of+     { ( _sepIcopy,sep_1) ->+         (case (value_) of+          { ( _valueIcopy,_valueImtokenPos,value_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      UnnamedField _valueIcopy _sepIcopy+                      {-# LINE 5570 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 5575 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Field_UnnamedField_1 :: T_Field_1+                            sem_Field_UnnamedField_1 =+                                (\ _lhsIconfig+                                   _lhsIfieldNames+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 163 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIfieldNames+                                             {-# LINE 5593 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _lhsOfieldNames ->+                                      (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIscopes+                                              {-# LINE 5598 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _valueOscopes ->+                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIisMeta+                                               {-# LINE 5603 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _valueOisMeta ->+                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIisInModule+                                                {-# LINE 5608 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _valueOisInModule ->+                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIglobalDefinitions+                                                 {-# LINE 5613 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _valueOglobalDefinitions ->+                                          (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIconfig+                                                  {-# LINE 5618 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _valueOconfig ->+                                           (case (({-# LINE 635 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   Nothing+                                                   {-# LINE 5623 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _valueOvarBeingDefined ->+                                            (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIvariableStyle+                                                    {-# LINE 5628 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _valueOvariableStyle ->+                                             (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIscopeLevel+                                                     {-# LINE 5633 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _valueOscopeLevel ->+                                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsImtokenPos+                                                      {-# LINE 5638 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _valueOmtokenPos ->+                                               (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIloopLevel+                                                       {-# LINE 5643 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _valueOloopLevel ->+                                                (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIfuncName+                                                        {-# LINE 5648 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _valueOfuncName ->+                                                 (case (({-# LINE 634 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         True+                                                         {-# LINE 5653 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _valueOtopLevel ->+                                                  (case (({-# LINE 633 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          True+                                                          {-# LINE 5658 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _valueOinParentheses ->+                                                   (case (({-# LINE 632 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           False+                                                           {-# LINE 5663 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _valueOisNegation ->+                                                    (case (value_1 _valueOconfig _valueOfuncName _valueOglobalDefinitions _valueOinParentheses _valueOisInModule _valueOisMeta _valueOisNegation _valueOloopLevel _valueOmtokenPos _valueOscopeLevel _valueOscopes _valueOtopLevel _valueOvarBeingDefined _valueOvariableStyle) of+                                                     { ( _valueIglobalDefinitions,_valueIidentifier,_valueIisInModule,_valueIisSimpleExpression,_valueIisSingleVar,_valueIscopes,_valueIvariableStyle,_valueIwarnings) ->+                                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _valueIglobalDefinitions+                                                                 {-# LINE 5670 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _sepOglobalDefinitions ->+                                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _valueIvariableStyle+                                                                  {-# LINE 5675 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _sepOvariableStyle ->+                                                           (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _valueIscopes+                                                                   {-# LINE 5680 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _sepOscopes ->+                                                            (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIscopeLevel+                                                                    {-# LINE 5685 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _sepOscopeLevel ->+                                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _valueImtokenPos+                                                                     {-# LINE 5690 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _sepOmtokenPos ->+                                                              (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIloopLevel+                                                                      {-# LINE 5695 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _sepOloopLevel ->+                                                               (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIisMeta+                                                                       {-# LINE 5700 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _sepOisMeta ->+                                                                (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _valueIisInModule+                                                                        {-# LINE 5705 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _sepOisInModule ->+                                                                 (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _lhsIfuncName+                                                                         {-# LINE 5710 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _sepOfuncName ->+                                                                  (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _lhsIconfig+                                                                          {-# LINE 5715 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _sepOconfig ->+                                                                   (case (sep_1 _sepOconfig _sepOfuncName _sepOglobalDefinitions _sepOisInModule _sepOisMeta _sepOloopLevel _sepOmtokenPos _sepOscopeLevel _sepOscopes _sepOvariableStyle) of+                                                                    { ( _sepIglobalDefinitions,_sepIidentifier,_sepIisInModule,_sepImtokenPos,_sepIscopes,_sepIvariableStyle,_sepIwarnings) ->+                                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _sepIglobalDefinitions+                                                                                {-# LINE 5722 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOglobalDefinitions ->+                                                                         (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 (const _valueIidentifier _sepIidentifier)+                                                                                 {-# LINE 5727 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOidentifier ->+                                                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _sepIisInModule+                                                                                  {-# LINE 5732 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOisInModule ->+                                                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _sepImtokenPos+                                                                                   {-# LINE 5737 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOmtokenPos ->+                                                                            (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _sepIscopes+                                                                                    {-# LINE 5742 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOscopes ->+                                                                             (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _sepIvariableStyle+                                                                                     {-# LINE 5747 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOvariableStyle ->+                                                                              (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _valueIwarnings ++ _sepIwarnings+                                                                                      {-# LINE 5752 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOwarnings ->+                                                                               ( _lhsOfieldNames,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Field_UnnamedField_1)) of+                 { ( sem_Field_1) ->+                 ( _lhsOcopy,sem_Field_1) }) }) }) }) })+-- FieldList ---------------------------------------------------+-- cata+sem_FieldList :: FieldList ->+                 T_FieldList+sem_FieldList list =+    (Prelude.foldr sem_FieldList_Cons sem_FieldList_Nil (Prelude.map sem_Field list))+-- semantic domain+type T_FieldList = ( FieldList,T_FieldList_1)+type T_FieldList_1 = LintSettings ->+                     (S.Set Token) ->+                     String ->+                     (M.Map String [Region]) ->+                     Bool ->+                     Bool ->+                     Int ->+                     Region ->+                     Int ->+                     ([M.Map String (Bool, Region)]) ->+                     DeterminedVariableStyle ->+                     ( (S.Set Token),(M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_FieldList = Inh_FieldList {config_Inh_FieldList :: LintSettings,fieldNames_Inh_FieldList :: (S.Set Token),funcName_Inh_FieldList :: String,globalDefinitions_Inh_FieldList :: (M.Map String [Region]),isInModule_Inh_FieldList :: Bool,isMeta_Inh_FieldList :: Bool,loopLevel_Inh_FieldList :: Int,mtokenPos_Inh_FieldList :: Region,scopeLevel_Inh_FieldList :: Int,scopes_Inh_FieldList :: ([M.Map String (Bool, Region)]),variableStyle_Inh_FieldList :: DeterminedVariableStyle}+data Syn_FieldList = Syn_FieldList {copy_Syn_FieldList :: FieldList,fieldNames_Syn_FieldList :: (S.Set Token),globalDefinitions_Syn_FieldList :: (M.Map String [Region]),identifier_Syn_FieldList :: String,isInModule_Syn_FieldList :: Bool,mtokenPos_Syn_FieldList :: Region,scopes_Syn_FieldList :: ([M.Map String (Bool, Region)]),variableStyle_Syn_FieldList :: DeterminedVariableStyle,warnings_Syn_FieldList :: ([String -> LintMessage])}+wrap_FieldList :: T_FieldList ->+                  Inh_FieldList ->+                  Syn_FieldList+wrap_FieldList sem (Inh_FieldList _lhsIconfig _lhsIfieldNames _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOfieldNames,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfieldNames _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_FieldList _lhsOcopy _lhsOfieldNames _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_FieldList_Cons :: T_Field ->+                      T_FieldList ->+                      T_FieldList+sem_FieldList_Cons hd_ tl_ =+    (case (tl_) of+     { ( _tlIcopy,tl_1) ->+         (case (hd_) of+          { ( _hdIcopy,hd_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (:) _hdIcopy _tlIcopy+                      {-# LINE 5798 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 5803 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_FieldList_Cons_1 :: T_FieldList_1+                            sem_FieldList_Cons_1 =+                                (\ _lhsIconfig+                                   _lhsIfieldNames+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 163 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIfieldNames+                                             {-# LINE 5821 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _hdOfieldNames ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 5826 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _hdOvariableStyle ->+                                       (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopes+                                               {-# LINE 5831 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _hdOscopes ->+                                        (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIscopeLevel+                                                {-# LINE 5836 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _hdOscopeLevel ->+                                         (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsImtokenPos+                                                 {-# LINE 5841 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _hdOmtokenPos ->+                                          (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIloopLevel+                                                  {-# LINE 5846 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _hdOloopLevel ->+                                           (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIisMeta+                                                   {-# LINE 5851 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _hdOisMeta ->+                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisInModule+                                                    {-# LINE 5856 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _hdOisInModule ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 5861 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _hdOglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 5866 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _hdOfuncName ->+                                               (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIconfig+                                                       {-# LINE 5871 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _hdOconfig ->+                                                (case (hd_1 _hdOconfig _hdOfieldNames _hdOfuncName _hdOglobalDefinitions _hdOisInModule _hdOisMeta _hdOloopLevel _hdOmtokenPos _hdOscopeLevel _hdOscopes _hdOvariableStyle) of+                                                 { ( _hdIfieldNames,_hdIglobalDefinitions,_hdIidentifier,_hdIisInModule,_hdImtokenPos,_hdIscopes,_hdIvariableStyle,_hdIwarnings) ->+                                                     (case (({-# LINE 163 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _hdIfieldNames+                                                             {-# LINE 5878 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _tlOfieldNames ->+                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _hdIvariableStyle+                                                              {-# LINE 5883 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _tlOvariableStyle ->+                                                       (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _hdIscopes+                                                               {-# LINE 5888 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _tlOscopes ->+                                                        (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _lhsIscopeLevel+                                                                {-# LINE 5893 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _tlOscopeLevel ->+                                                         (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _hdImtokenPos+                                                                 {-# LINE 5898 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _tlOmtokenPos ->+                                                          (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIloopLevel+                                                                  {-# LINE 5903 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _tlOloopLevel ->+                                                           (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIisMeta+                                                                   {-# LINE 5908 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _tlOisMeta ->+                                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _hdIisInModule+                                                                    {-# LINE 5913 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _tlOisInModule ->+                                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _hdIglobalDefinitions+                                                                     {-# LINE 5918 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _tlOglobalDefinitions ->+                                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIfuncName+                                                                      {-# LINE 5923 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _tlOfuncName ->+                                                               (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIconfig+                                                                       {-# LINE 5928 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _tlOconfig ->+                                                                (case (tl_1 _tlOconfig _tlOfieldNames _tlOfuncName _tlOglobalDefinitions _tlOisInModule _tlOisMeta _tlOloopLevel _tlOmtokenPos _tlOscopeLevel _tlOscopes _tlOvariableStyle) of+                                                                 { ( _tlIfieldNames,_tlIglobalDefinitions,_tlIidentifier,_tlIisInModule,_tlImtokenPos,_tlIscopes,_tlIvariableStyle,_tlIwarnings) ->+                                                                     (case (({-# LINE 163 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _tlIfieldNames+                                                                             {-# LINE 5935 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _lhsOfieldNames ->+                                                                      (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _tlIglobalDefinitions+                                                                              {-# LINE 5940 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _lhsOglobalDefinitions ->+                                                                       (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               (const _hdIidentifier _tlIidentifier)+                                                                               {-# LINE 5945 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOidentifier ->+                                                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _tlIisInModule+                                                                                {-# LINE 5950 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOisInModule ->+                                                                         (case (({-# LINE 234 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _hdImtokenPos+                                                                                 {-# LINE 5955 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOmtokenPos ->+                                                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _tlIscopes+                                                                                  {-# LINE 5960 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOscopes ->+                                                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _tlIvariableStyle+                                                                                   {-# LINE 5965 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOvariableStyle ->+                                                                            (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _hdIwarnings ++ _tlIwarnings+                                                                                    {-# LINE 5970 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOwarnings ->+                                                                             ( _lhsOfieldNames,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_FieldList_Cons_1)) of+                 { ( sem_FieldList_1) ->+                 ( _lhsOcopy,sem_FieldList_1) }) }) }) }) })+sem_FieldList_Nil :: T_FieldList+sem_FieldList_Nil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            []+            {-# LINE 5981 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 5986 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_FieldList_Nil_1 :: T_FieldList_1+                  sem_FieldList_Nil_1 =+                      (\ _lhsIconfig+                         _lhsIfieldNames+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 163 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIfieldNames+                                   {-# LINE 6004 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOfieldNames ->+                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    _lhsIglobalDefinitions+                                    {-# LINE 6009 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOglobalDefinitions ->+                             (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     unknownIdentifier+                                     {-# LINE 6014 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOidentifier ->+                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsIisInModule+                                      {-# LINE 6019 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisInModule ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 6024 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 6029 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 6034 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 6039 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOfieldNames,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_FieldList_Nil_1)) of+       { ( sem_FieldList_1) ->+       ( _lhsOcopy,sem_FieldList_1) }) }) })+-- FieldSep ----------------------------------------------------+-- cata+sem_FieldSep :: FieldSep ->+                T_FieldSep+sem_FieldSep (CommaSep) =+    (sem_FieldSep_CommaSep)+sem_FieldSep (SemicolonSep) =+    (sem_FieldSep_SemicolonSep)+sem_FieldSep (NoSep) =+    (sem_FieldSep_NoSep)+-- semantic domain+type T_FieldSep = ( FieldSep,T_FieldSep_1)+type T_FieldSep_1 = LintSettings ->+                    String ->+                    (M.Map String [Region]) ->+                    Bool ->+                    Bool ->+                    Int ->+                    Region ->+                    Int ->+                    ([M.Map String (Bool, Region)]) ->+                    DeterminedVariableStyle ->+                    ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_FieldSep = Inh_FieldSep {config_Inh_FieldSep :: LintSettings,funcName_Inh_FieldSep :: String,globalDefinitions_Inh_FieldSep :: (M.Map String [Region]),isInModule_Inh_FieldSep :: Bool,isMeta_Inh_FieldSep :: Bool,loopLevel_Inh_FieldSep :: Int,mtokenPos_Inh_FieldSep :: Region,scopeLevel_Inh_FieldSep :: Int,scopes_Inh_FieldSep :: ([M.Map String (Bool, Region)]),variableStyle_Inh_FieldSep :: DeterminedVariableStyle}+data Syn_FieldSep = Syn_FieldSep {copy_Syn_FieldSep :: FieldSep,globalDefinitions_Syn_FieldSep :: (M.Map String [Region]),identifier_Syn_FieldSep :: String,isInModule_Syn_FieldSep :: Bool,mtokenPos_Syn_FieldSep :: Region,scopes_Syn_FieldSep :: ([M.Map String (Bool, Region)]),variableStyle_Syn_FieldSep :: DeterminedVariableStyle,warnings_Syn_FieldSep :: ([String -> LintMessage])}+wrap_FieldSep :: T_FieldSep ->+                 Inh_FieldSep ->+                 Syn_FieldSep+wrap_FieldSep sem (Inh_FieldSep _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_FieldSep _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_FieldSep_CommaSep :: T_FieldSep+sem_FieldSep_CommaSep =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            CommaSep+            {-# LINE 6082 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 6087 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_FieldSep_CommaSep_1 :: T_FieldSep_1+                  sem_FieldSep_CommaSep_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 6104 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 6109 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 6114 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 6119 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 6124 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 6129 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 6134 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_FieldSep_CommaSep_1)) of+       { ( sem_FieldSep_1) ->+       ( _lhsOcopy,sem_FieldSep_1) }) }) })+sem_FieldSep_SemicolonSep :: T_FieldSep+sem_FieldSep_SemicolonSep =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            SemicolonSep+            {-# LINE 6145 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 6150 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_FieldSep_SemicolonSep_1 :: T_FieldSep_1+                  sem_FieldSep_SemicolonSep_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 6167 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 6172 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 6177 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 6182 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 6187 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 6192 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 6197 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_FieldSep_SemicolonSep_1)) of+       { ( sem_FieldSep_1) ->+       ( _lhsOcopy,sem_FieldSep_1) }) }) })+sem_FieldSep_NoSep :: T_FieldSep+sem_FieldSep_NoSep =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            NoSep+            {-# LINE 6208 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 6213 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_FieldSep_NoSep_1 :: T_FieldSep_1+                  sem_FieldSep_NoSep_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 6230 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 6235 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 6240 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 6245 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 6250 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 6255 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 6260 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_FieldSep_NoSep_1)) of+       { ( sem_FieldSep_1) ->+       ( _lhsOcopy,sem_FieldSep_1) }) }) })+-- FuncName ----------------------------------------------------+-- cata+sem_FuncName :: FuncName ->+                T_FuncName+sem_FuncName (FuncName _names _meta) =+    (sem_FuncName_FuncName _names _meta)+-- semantic domain+type T_FuncName = ( FuncName,Bool,T_FuncName_1)+type T_FuncName_1 = LintSettings ->+                    String ->+                    (M.Map String [Region]) ->+                    Bool ->+                    Bool ->+                    Int ->+                    Region ->+                    Int ->+                    ([M.Map String (Bool, Region)]) ->+                    DeterminedVariableStyle ->+                    ( (M.Map String [Region]),Bool,String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_FuncName = Inh_FuncName {config_Inh_FuncName :: LintSettings,funcName_Inh_FuncName :: String,globalDefinitions_Inh_FuncName :: (M.Map String [Region]),isInModule_Inh_FuncName :: Bool,isMeta_Inh_FuncName :: Bool,loopLevel_Inh_FuncName :: Int,mtokenPos_Inh_FuncName :: Region,scopeLevel_Inh_FuncName :: Int,scopes_Inh_FuncName :: ([M.Map String (Bool, Region)]),variableStyle_Inh_FuncName :: DeterminedVariableStyle}+data Syn_FuncName = Syn_FuncName {copy_Syn_FuncName :: FuncName,globalDefinitions_Syn_FuncName :: (M.Map String [Region]),hasSuffixes_Syn_FuncName :: Bool,identifier_Syn_FuncName :: String,isInModule_Syn_FuncName :: Bool,isMeta_Syn_FuncName :: Bool,mtokenPos_Syn_FuncName :: Region,scopes_Syn_FuncName :: ([M.Map String (Bool, Region)]),variableStyle_Syn_FuncName :: DeterminedVariableStyle,warnings_Syn_FuncName :: ([String -> LintMessage])}+wrap_FuncName :: T_FuncName ->+                 Inh_FuncName ->+                 Syn_FuncName+wrap_FuncName sem (Inh_FuncName _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,_lhsOisMeta,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOhasSuffixes,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_FuncName _lhsOcopy _lhsOglobalDefinitions _lhsOhasSuffixes _lhsOidentifier _lhsOisInModule _lhsOisMeta _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_FuncName_FuncName :: ([MToken]) ->+                         (Maybe MToken) ->+                         T_FuncName+sem_FuncName_FuncName names_ meta_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            FuncName names_ meta_+            {-# LINE 6301 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 6306 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 501 "src/GLuaFixer/AG/ASTLint.ag" #-}+              isJust meta_+              {-# LINE 6311 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOisMeta ->+       (case ((let sem_FuncName_FuncName_1 :: T_FuncName_1+                   sem_FuncName_FuncName_1 =+                       (\ _lhsIconfig+                          _lhsIfuncName+                          _lhsIglobalDefinitions+                          _lhsIisInModule+                          _lhsIisMeta+                          _lhsIloopLevel+                          _lhsImtokenPos+                          _lhsIscopeLevel+                          _lhsIscopes+                          _lhsIvariableStyle ->+                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    _lhsIglobalDefinitions+                                    {-# LINE 6328 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOglobalDefinitions ->+                             (case (({-# LINE 502 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     length names_ > 1+                                     {-# LINE 6333 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOhasSuffixes ->+                              (case (({-# LINE 500 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      tokenLabel . head $ names_+                                      {-# LINE 6338 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOidentifier ->+                               (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIisInModule+                                       {-# LINE 6343 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOisInModule ->+                                (case (({-# LINE 499 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        mpos (head names_)+                                        {-# LINE 6348 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOmtokenPos ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 6353 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOscopes ->+                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIvariableStyle+                                          {-# LINE 6358 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOvariableStyle ->+                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           []+                                           {-# LINE 6363 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lhsOwarnings ->+                                    ( _lhsOglobalDefinitions,_lhsOhasSuffixes,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+               in  sem_FuncName_FuncName_1)) of+        { ( sem_FuncName_1) ->+        ( _lhsOcopy,_lhsOisMeta,sem_FuncName_1) }) }) }) })+-- MElse -------------------------------------------------------+-- cata+sem_MElse :: MElse ->+             T_MElse+sem_MElse (MElse _pos _body) =+    (sem_MElse_MElse (sem_Region _pos) (sem_Block _body))+-- semantic domain+type T_MElse = ( MElse,T_MElse_1)+type T_MElse_1 = LintSettings ->+                 String ->+                 (M.Map String [Region]) ->+                 Bool ->+                 Bool ->+                 Int ->+                 Region ->+                 Int ->+                 ([M.Map String (Bool, Region)]) ->+                 DeterminedVariableStyle ->+                 ( Bool,(M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),Int,DeterminedVariableStyle,([String -> LintMessage]))+data Inh_MElse = Inh_MElse {config_Inh_MElse :: LintSettings,funcName_Inh_MElse :: String,globalDefinitions_Inh_MElse :: (M.Map String [Region]),isInModule_Inh_MElse :: Bool,isMeta_Inh_MElse :: Bool,loopLevel_Inh_MElse :: Int,mtokenPos_Inh_MElse :: Region,scopeLevel_Inh_MElse :: Int,scopes_Inh_MElse :: ([M.Map String (Bool, Region)]),variableStyle_Inh_MElse :: DeterminedVariableStyle}+data Syn_MElse = Syn_MElse {copy_Syn_MElse :: MElse,elseExists_Syn_MElse :: Bool,globalDefinitions_Syn_MElse :: (M.Map String [Region]),identifier_Syn_MElse :: String,isInModule_Syn_MElse :: Bool,mtokenPos_Syn_MElse :: Region,scopes_Syn_MElse :: ([M.Map String (Bool, Region)]),statementCount_Syn_MElse :: Int,variableStyle_Syn_MElse :: DeterminedVariableStyle,warnings_Syn_MElse :: ([String -> LintMessage])}+wrap_MElse :: T_MElse ->+              Inh_MElse ->+              Syn_MElse+wrap_MElse sem (Inh_MElse _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOelseExists,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_MElse _lhsOcopy _lhsOelseExists _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOstatementCount _lhsOvariableStyle _lhsOwarnings))+sem_MElse_MElse :: T_Region ->+                   T_Block ->+                   T_MElse+sem_MElse_MElse pos_ body_ =+    (case (body_) of+     { ( _bodyIcopy,body_1) ->+         (case (pos_) of+          { ( _posIcopy,_posIidentifier,_posIwarnings) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      MElse _posIcopy _bodyIcopy+                      {-# LINE 6408 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 6413 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_MElse_MElse_1 :: T_MElse_1+                            sem_MElse_MElse_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 202 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             False+                                             {-# LINE 6430 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _lhsOelseExists ->+                                      (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIscopes+                                              {-# LINE 6435 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _bodyOscopes ->+                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIisMeta+                                               {-# LINE 6440 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _bodyOisMeta ->+                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIisInModule+                                                {-# LINE 6445 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _bodyOisInModule ->+                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIglobalDefinitions+                                                 {-# LINE 6450 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _bodyOglobalDefinitions ->+                                          (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIconfig+                                                  {-# LINE 6455 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _bodyOconfig ->+                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIvariableStyle+                                                   {-# LINE 6460 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _bodyOvariableStyle ->+                                            (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIscopeLevel+                                                    {-# LINE 6465 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _bodyOscopeLevel ->+                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsImtokenPos+                                                     {-# LINE 6470 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _bodyOmtokenPos ->+                                              (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIloopLevel+                                                      {-# LINE 6475 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _bodyOloopLevel ->+                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIfuncName+                                                       {-# LINE 6480 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _bodyOfuncName ->+                                                (case (({-# LINE 479 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        False+                                                        {-# LINE 6485 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _bodyOisRepeat ->+                                                 (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                                  { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                      (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _bodyIglobalDefinitions+                                                              {-# LINE 6492 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOglobalDefinitions ->+                                                       (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               (const _posIidentifier _bodyIidentifier)+                                                               {-# LINE 6497 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOidentifier ->+                                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _bodyIisInModule+                                                                {-# LINE 6502 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOisInModule ->+                                                         (case (({-# LINE 480 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _posIcopy+                                                                 {-# LINE 6507 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOmtokenPos ->+                                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _bodyIscopes+                                                                  {-# LINE 6512 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOscopes ->+                                                           (case (({-# LINE 157 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _bodyIstatementCount+                                                                   {-# LINE 6517 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _lhsOstatementCount ->+                                                            (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _bodyIvariableStyle+                                                                    {-# LINE 6522 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _lhsOvariableStyle ->+                                                             (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _posIwarnings ++ _bodyIwarnings+                                                                     {-# LINE 6527 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _lhsOwarnings ->+                                                              ( _lhsOelseExists,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_MElse_MElse_1)) of+                 { ( sem_MElse_1) ->+                 ( _lhsOcopy,sem_MElse_1) }) }) }) }) })+-- MElseIf -----------------------------------------------------+-- cata+sem_MElseIf :: MElseIf ->+               T_MElseIf+sem_MElseIf (MElseIf _pos _elif) =+    (sem_MElseIf_MElseIf (sem_Region _pos) (sem_ElseIf _elif))+-- semantic domain+type T_MElseIf = ( MElseIf,T_MElseIf_1)+type T_MElseIf_1 = LintSettings ->+                   String ->+                   (M.Map String [Region]) ->+                   Bool ->+                   Bool ->+                   Int ->+                   Region ->+                   Int ->+                   ([M.Map String (Bool, Region)]) ->+                   DeterminedVariableStyle ->+                   ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_MElseIf = Inh_MElseIf {config_Inh_MElseIf :: LintSettings,funcName_Inh_MElseIf :: String,globalDefinitions_Inh_MElseIf :: (M.Map String [Region]),isInModule_Inh_MElseIf :: Bool,isMeta_Inh_MElseIf :: Bool,loopLevel_Inh_MElseIf :: Int,mtokenPos_Inh_MElseIf :: Region,scopeLevel_Inh_MElseIf :: Int,scopes_Inh_MElseIf :: ([M.Map String (Bool, Region)]),variableStyle_Inh_MElseIf :: DeterminedVariableStyle}+data Syn_MElseIf = Syn_MElseIf {copy_Syn_MElseIf :: MElseIf,globalDefinitions_Syn_MElseIf :: (M.Map String [Region]),identifier_Syn_MElseIf :: String,isInModule_Syn_MElseIf :: Bool,mtokenPos_Syn_MElseIf :: Region,scopes_Syn_MElseIf :: ([M.Map String (Bool, Region)]),variableStyle_Syn_MElseIf :: DeterminedVariableStyle,warnings_Syn_MElseIf :: ([String -> LintMessage])}+wrap_MElseIf :: T_MElseIf ->+                Inh_MElseIf ->+                Syn_MElseIf+wrap_MElseIf sem (Inh_MElseIf _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_MElseIf _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_MElseIf_MElseIf :: T_Region ->+                       T_ElseIf ->+                       T_MElseIf+sem_MElseIf_MElseIf pos_ elif_ =+    (case (elif_) of+     { ( _elifIcopy,elif_1) ->+         (case (pos_) of+          { ( _posIcopy,_posIidentifier,_posIwarnings) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      MElseIf _posIcopy _elifIcopy+                      {-# LINE 6572 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 6577 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_MElseIf_MElseIf_1 :: T_MElseIf_1+                            sem_MElseIf_MElseIf_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 6594 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _elifOscopes ->+                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisMeta+                                              {-# LINE 6599 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _elifOisMeta ->+                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIisInModule+                                               {-# LINE 6604 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _elifOisInModule ->+                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIglobalDefinitions+                                                {-# LINE 6609 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _elifOglobalDefinitions ->+                                         (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIconfig+                                                 {-# LINE 6614 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _elifOconfig ->+                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIvariableStyle+                                                  {-# LINE 6619 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _elifOvariableStyle ->+                                           (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIscopeLevel+                                                   {-# LINE 6624 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _elifOscopeLevel ->+                                            (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIloopLevel+                                                    {-# LINE 6629 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _elifOloopLevel ->+                                             (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIfuncName+                                                     {-# LINE 6634 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _elifOfuncName ->+                                              (case (({-# LINE 463 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _posIcopy+                                                      {-# LINE 6639 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _elifOmtokenPos ->+                                               (case (elif_1 _elifOconfig _elifOfuncName _elifOglobalDefinitions _elifOisInModule _elifOisMeta _elifOloopLevel _elifOmtokenPos _elifOscopeLevel _elifOscopes _elifOvariableStyle) of+                                                { ( _elifIglobalDefinitions,_elifIidentifier,_elifIisInModule,_elifImtokenPos,_elifIscopes,_elifIvariableStyle,_elifIwarnings) ->+                                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _elifIglobalDefinitions+                                                            {-# LINE 6646 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOglobalDefinitions ->+                                                     (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             (const _posIidentifier _elifIidentifier)+                                                             {-# LINE 6651 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOidentifier ->+                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _elifIisInModule+                                                              {-# LINE 6656 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOisInModule ->+                                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _elifImtokenPos+                                                               {-# LINE 6661 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOmtokenPos ->+                                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _elifIscopes+                                                                {-# LINE 6666 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOscopes ->+                                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _elifIvariableStyle+                                                                 {-# LINE 6671 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOvariableStyle ->+                                                          (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _posIwarnings ++ _elifIwarnings+                                                                  {-# LINE 6676 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOwarnings ->+                                                           ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_MElseIf_MElseIf_1)) of+                 { ( sem_MElseIf_1) ->+                 ( _lhsOcopy,sem_MElseIf_1) }) }) }) }) })+-- MExpr -------------------------------------------------------+-- cata+sem_MExpr :: MExpr ->+             T_MExpr+sem_MExpr (MExpr _pos _expr) =+    (sem_MExpr_MExpr (sem_Region _pos) (sem_Expr _expr))+-- semantic domain+type T_MExpr = ( MExpr,Region,T_MExpr_1)+type T_MExpr_1 = LintSettings ->+                 String ->+                 (M.Map String [Region]) ->+                 Bool ->+                 Bool ->+                 Bool ->+                 Bool ->+                 Int ->+                 Region ->+                 Int ->+                 ([M.Map String (Bool, Region)]) ->+                 Bool ->+                 (Maybe MToken) ->+                 DeterminedVariableStyle ->+                 ( (M.Map String [Region]),String,Bool,Bool,(Maybe MToken),([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_MExpr = Inh_MExpr {config_Inh_MExpr :: LintSettings,funcName_Inh_MExpr :: String,globalDefinitions_Inh_MExpr :: (M.Map String [Region]),inParentheses_Inh_MExpr :: Bool,isInModule_Inh_MExpr :: Bool,isMeta_Inh_MExpr :: Bool,isNegation_Inh_MExpr :: Bool,loopLevel_Inh_MExpr :: Int,mtokenPos_Inh_MExpr :: Region,scopeLevel_Inh_MExpr :: Int,scopes_Inh_MExpr :: ([M.Map String (Bool, Region)]),topLevel_Inh_MExpr :: Bool,varBeingDefined_Inh_MExpr :: (Maybe MToken),variableStyle_Inh_MExpr :: DeterminedVariableStyle}+data Syn_MExpr = Syn_MExpr {copy_Syn_MExpr :: MExpr,globalDefinitions_Syn_MExpr :: (M.Map String [Region]),identifier_Syn_MExpr :: String,isInModule_Syn_MExpr :: Bool,isSimpleExpression_Syn_MExpr :: Bool,isSingleVar_Syn_MExpr :: (Maybe MToken),mtokenPos_Syn_MExpr :: Region,scopes_Syn_MExpr :: ([M.Map String (Bool, Region)]),variableStyle_Syn_MExpr :: DeterminedVariableStyle,warnings_Syn_MExpr :: ([String -> LintMessage])}+wrap_MExpr :: T_MExpr ->+              Inh_MExpr ->+              Syn_MExpr+wrap_MExpr sem (Inh_MExpr _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIinParentheses _lhsIisInModule _lhsIisMeta _lhsIisNegation _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsItopLevel _lhsIvarBeingDefined _lhsIvariableStyle) =+    (let ( _lhsOcopy,_lhsOmtokenPos,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIinParentheses _lhsIisInModule _lhsIisMeta _lhsIisNegation _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsItopLevel _lhsIvarBeingDefined _lhsIvariableStyle+     in  (Syn_MExpr _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOisSimpleExpression _lhsOisSingleVar _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_MExpr_MExpr :: T_Region ->+                   T_Expr ->+                   T_MExpr+sem_MExpr_MExpr pos_ expr_ =+    (case (expr_) of+     { ( _exprIcopy,expr_1) ->+         (case (pos_) of+          { ( _posIcopy,_posIidentifier,_posIwarnings) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      MExpr _posIcopy _exprIcopy+                      {-# LINE 6725 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 6730 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case (({-# LINE 557 "src/GLuaFixer/AG/ASTLint.ag" #-}+                        _posIcopy+                        {-# LINE 6735 "src/GLuaFixer/AG/ASTLint.hs" #-}+                        )) of+                 { _lhsOmtokenPos ->+                 (case ((let sem_MExpr_MExpr_1 :: T_MExpr_1+                             sem_MExpr_MExpr_1 =+                                 (\ _lhsIconfig+                                    _lhsIfuncName+                                    _lhsIglobalDefinitions+                                    _lhsIinParentheses+                                    _lhsIisInModule+                                    _lhsIisMeta+                                    _lhsIisNegation+                                    _lhsIloopLevel+                                    _lhsImtokenPos+                                    _lhsIscopeLevel+                                    _lhsIscopes+                                    _lhsItopLevel+                                    _lhsIvarBeingDefined+                                    _lhsIvariableStyle ->+                                      (case (({-# LINE 178 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvarBeingDefined+                                              {-# LINE 6756 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _exprOvarBeingDefined ->+                                       (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopes+                                               {-# LINE 6761 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _exprOscopes ->+                                        (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIisMeta+                                                {-# LINE 6766 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _exprOisMeta ->+                                         (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIisInModule+                                                 {-# LINE 6771 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _exprOisInModule ->+                                          (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIglobalDefinitions+                                                  {-# LINE 6776 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _exprOglobalDefinitions ->+                                           (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIconfig+                                                   {-# LINE 6781 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _exprOconfig ->+                                            (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIvariableStyle+                                                    {-# LINE 6786 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _exprOvariableStyle ->+                                             (case (({-# LINE 182 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsItopLevel+                                                     {-# LINE 6791 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _exprOtopLevel ->+                                              (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIscopeLevel+                                                      {-# LINE 6796 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _exprOscopeLevel ->+                                               (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIloopLevel+                                                       {-# LINE 6801 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _exprOloopLevel ->+                                                (case (({-# LINE 169 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIisNegation+                                                        {-# LINE 6806 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _exprOisNegation ->+                                                 (case (({-# LINE 181 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsIinParentheses+                                                         {-# LINE 6811 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _exprOinParentheses ->+                                                  (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIfuncName+                                                          {-# LINE 6816 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _exprOfuncName ->+                                                   (case (({-# LINE 558 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _posIcopy+                                                           {-# LINE 6821 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _exprOmtokenPos ->+                                                    (case (expr_1 _exprOconfig _exprOfuncName _exprOglobalDefinitions _exprOinParentheses _exprOisInModule _exprOisMeta _exprOisNegation _exprOloopLevel _exprOmtokenPos _exprOscopeLevel _exprOscopes _exprOtopLevel _exprOvarBeingDefined _exprOvariableStyle) of+                                                     { ( _exprIglobalDefinitions,_exprIidentifier,_exprIisInModule,_exprIisSimpleExpression,_exprIisSingleVar,_exprImtokenPos,_exprIscopes,_exprIvariableStyle,_exprIwarnings) ->+                                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _exprIglobalDefinitions+                                                                 {-# LINE 6828 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOglobalDefinitions ->+                                                          (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  (const _posIidentifier _exprIidentifier)+                                                                  {-# LINE 6833 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOidentifier ->+                                                           (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _exprIisInModule+                                                                   {-# LINE 6838 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _lhsOisInModule ->+                                                            (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _exprIisSimpleExpression+                                                                    {-# LINE 6843 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _lhsOisSimpleExpression ->+                                                             (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _exprIisSingleVar+                                                                     {-# LINE 6848 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _lhsOisSingleVar ->+                                                              (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _exprIscopes+                                                                      {-# LINE 6853 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _lhsOscopes ->+                                                               (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _exprIvariableStyle+                                                                       {-# LINE 6858 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _lhsOvariableStyle ->+                                                                (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _posIwarnings ++ _exprIwarnings+                                                                        {-# LINE 6863 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _lhsOwarnings ->+                                                                 ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                         in  sem_MExpr_MExpr_1)) of+                  { ( sem_MExpr_1) ->+                  ( _lhsOcopy,_lhsOmtokenPos,sem_MExpr_1) }) }) }) }) }) })+-- MExprList ---------------------------------------------------+-- cata+sem_MExprList :: MExprList ->+                 T_MExprList+sem_MExprList list =+    (Prelude.foldr sem_MExprList_Cons sem_MExprList_Nil (Prelude.map sem_MExpr list))+-- semantic domain+type T_MExprList = ( MExprList,T_MExprList_1)+type T_MExprList_1 = LintSettings ->+                     String ->+                     (M.Map String [Region]) ->+                     Bool ->+                     Bool ->+                     Bool ->+                     Int ->+                     Region ->+                     Int ->+                     ([M.Map String (Bool, Region)]) ->+                     Bool ->+                     DeterminedVariableStyle ->+                     ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_MExprList = Inh_MExprList {config_Inh_MExprList :: LintSettings,funcName_Inh_MExprList :: String,globalDefinitions_Inh_MExprList :: (M.Map String [Region]),inParentheses_Inh_MExprList :: Bool,isInModule_Inh_MExprList :: Bool,isMeta_Inh_MExprList :: Bool,loopLevel_Inh_MExprList :: Int,mtokenPos_Inh_MExprList :: Region,scopeLevel_Inh_MExprList :: Int,scopes_Inh_MExprList :: ([M.Map String (Bool, Region)]),topLevel_Inh_MExprList :: Bool,variableStyle_Inh_MExprList :: DeterminedVariableStyle}+data Syn_MExprList = Syn_MExprList {copy_Syn_MExprList :: MExprList,globalDefinitions_Syn_MExprList :: (M.Map String [Region]),identifier_Syn_MExprList :: String,isInModule_Syn_MExprList :: Bool,mtokenPos_Syn_MExprList :: Region,scopes_Syn_MExprList :: ([M.Map String (Bool, Region)]),variableStyle_Syn_MExprList :: DeterminedVariableStyle,warnings_Syn_MExprList :: ([String -> LintMessage])}+wrap_MExprList :: T_MExprList ->+                  Inh_MExprList ->+                  Syn_MExprList+wrap_MExprList sem (Inh_MExprList _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIinParentheses _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsItopLevel _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIinParentheses _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsItopLevel _lhsIvariableStyle+     in  (Syn_MExprList _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_MExprList_Cons :: T_MExpr ->+                      T_MExprList ->+                      T_MExprList+sem_MExprList_Cons hd_ tl_ =+    (case (tl_) of+     { ( _tlIcopy,tl_1) ->+         (case (hd_) of+          { ( _hdIcopy,_hdImtokenPos,hd_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (:) _hdIcopy _tlIcopy+                      {-# LINE 6910 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 6915 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_MExprList_Cons_1 :: T_MExprList_1+                            sem_MExprList_Cons_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIinParentheses+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsItopLevel+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 6934 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _hdOscopes ->+                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisMeta+                                              {-# LINE 6939 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _hdOisMeta ->+                                       (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIconfig+                                               {-# LINE 6944 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _hdOconfig ->+                                        (case (({-# LINE 245 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                Nothing+                                                {-# LINE 6949 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _hdOvarBeingDefined ->+                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIvariableStyle+                                                 {-# LINE 6954 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _hdOvariableStyle ->+                                          (case (({-# LINE 182 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsItopLevel+                                                  {-# LINE 6959 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _hdOtopLevel ->+                                           (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIscopeLevel+                                                   {-# LINE 6964 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _hdOscopeLevel ->+                                            (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsImtokenPos+                                                    {-# LINE 6969 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _hdOmtokenPos ->+                                             (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIloopLevel+                                                     {-# LINE 6974 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _hdOloopLevel ->+                                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIisInModule+                                                      {-# LINE 6979 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _hdOisInModule ->+                                               (case (({-# LINE 181 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIinParentheses+                                                       {-# LINE 6984 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _hdOinParentheses ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIglobalDefinitions+                                                        {-# LINE 6989 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _hdOglobalDefinitions ->+                                                 (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsIfuncName+                                                         {-# LINE 6994 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _hdOfuncName ->+                                                  (case (({-# LINE 244 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          False+                                                          {-# LINE 6999 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _hdOisNegation ->+                                                   (case (hd_1 _hdOconfig _hdOfuncName _hdOglobalDefinitions _hdOinParentheses _hdOisInModule _hdOisMeta _hdOisNegation _hdOloopLevel _hdOmtokenPos _hdOscopeLevel _hdOscopes _hdOtopLevel _hdOvarBeingDefined _hdOvariableStyle) of+                                                    { ( _hdIglobalDefinitions,_hdIidentifier,_hdIisInModule,_hdIisSimpleExpression,_hdIisSingleVar,_hdIscopes,_hdIvariableStyle,_hdIwarnings) ->+                                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _hdIscopes+                                                                {-# LINE 7006 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _tlOscopes ->+                                                         (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _lhsIisMeta+                                                                 {-# LINE 7011 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _tlOisMeta ->+                                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _hdIisInModule+                                                                  {-# LINE 7016 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _tlOisInModule ->+                                                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _hdIglobalDefinitions+                                                                   {-# LINE 7021 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _tlOglobalDefinitions ->+                                                            (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIconfig+                                                                    {-# LINE 7026 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _tlOconfig ->+                                                             (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _hdIvariableStyle+                                                                     {-# LINE 7031 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _tlOvariableStyle ->+                                                              (case (({-# LINE 182 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsItopLevel+                                                                      {-# LINE 7036 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _tlOtopLevel ->+                                                               (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIscopeLevel+                                                                       {-# LINE 7041 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _tlOscopeLevel ->+                                                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _hdImtokenPos+                                                                        {-# LINE 7046 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _tlOmtokenPos ->+                                                                 (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _lhsIloopLevel+                                                                         {-# LINE 7051 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _tlOloopLevel ->+                                                                  (case (({-# LINE 181 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _lhsIinParentheses+                                                                          {-# LINE 7056 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _tlOinParentheses ->+                                                                   (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           _lhsIfuncName+                                                                           {-# LINE 7061 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _tlOfuncName ->+                                                                    (case (tl_1 _tlOconfig _tlOfuncName _tlOglobalDefinitions _tlOinParentheses _tlOisInModule _tlOisMeta _tlOloopLevel _tlOmtokenPos _tlOscopeLevel _tlOscopes _tlOtopLevel _tlOvariableStyle) of+                                                                     { ( _tlIglobalDefinitions,_tlIidentifier,_tlIisInModule,_tlImtokenPos,_tlIscopes,_tlIvariableStyle,_tlIwarnings) ->+                                                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _tlIglobalDefinitions+                                                                                 {-# LINE 7068 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOglobalDefinitions ->+                                                                          (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  (const _hdIidentifier _tlIidentifier)+                                                                                  {-# LINE 7073 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOidentifier ->+                                                                           (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _tlIisInModule+                                                                                   {-# LINE 7078 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOisInModule ->+                                                                            (case (({-# LINE 234 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _hdImtokenPos+                                                                                    {-# LINE 7083 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOmtokenPos ->+                                                                             (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _tlIscopes+                                                                                     {-# LINE 7088 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOscopes ->+                                                                              (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _tlIvariableStyle+                                                                                      {-# LINE 7093 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOvariableStyle ->+                                                                               (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _hdIwarnings ++ _tlIwarnings+                                                                                       {-# LINE 7098 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _lhsOwarnings ->+                                                                                ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_MExprList_Cons_1)) of+                 { ( sem_MExprList_1) ->+                 ( _lhsOcopy,sem_MExprList_1) }) }) }) }) })+sem_MExprList_Nil :: T_MExprList+sem_MExprList_Nil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            []+            {-# LINE 7109 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 7114 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_MExprList_Nil_1 :: T_MExprList_1+                  sem_MExprList_Nil_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIinParentheses+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsItopLevel+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 7133 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 7138 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 7143 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 7148 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 7153 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 7158 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 7163 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_MExprList_Nil_1)) of+       { ( sem_MExprList_1) ->+       ( _lhsOcopy,sem_MExprList_1) }) }) })+-- MStat -------------------------------------------------------+-- cata+sem_MStat :: MStat ->+             T_MStat+sem_MStat (MStat _pos _stat) =+    (sem_MStat_MStat (sem_Region _pos) (sem_Stat _stat))+-- semantic domain+type T_MStat = ( MStat,T_MStat_1)+type T_MStat_1 = LintSettings ->+                 String ->+                 (M.Map String [Region]) ->+                 Bool ->+                 Bool ->+                 Int ->+                 Region ->+                 Int ->+                 ([M.Map String (Bool, Region)]) ->+                 DeterminedVariableStyle ->+                 ( (M.Map String [Region]),String,Bool,Bool,Region,([M.Map String (Bool, Region)]),Int,DeterminedVariableStyle,([String -> LintMessage]))+data Inh_MStat = Inh_MStat {config_Inh_MStat :: LintSettings,funcName_Inh_MStat :: String,globalDefinitions_Inh_MStat :: (M.Map String [Region]),isInModule_Inh_MStat :: Bool,isMeta_Inh_MStat :: Bool,loopLevel_Inh_MStat :: Int,mtokenPos_Inh_MStat :: Region,scopeLevel_Inh_MStat :: Int,scopes_Inh_MStat :: ([M.Map String (Bool, Region)]),variableStyle_Inh_MStat :: DeterminedVariableStyle}+data Syn_MStat = Syn_MStat {copy_Syn_MStat :: MStat,globalDefinitions_Syn_MStat :: (M.Map String [Region]),identifier_Syn_MStat :: String,isIfStatement_Syn_MStat :: Bool,isInModule_Syn_MStat :: Bool,mtokenPos_Syn_MStat :: Region,scopes_Syn_MStat :: ([M.Map String (Bool, Region)]),statementCount_Syn_MStat :: Int,variableStyle_Syn_MStat :: DeterminedVariableStyle,warnings_Syn_MStat :: ([String -> LintMessage])}+wrap_MStat :: T_MStat ->+              Inh_MStat ->+              Syn_MStat+wrap_MStat sem (Inh_MStat _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_MStat _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisIfStatement _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOstatementCount _lhsOvariableStyle _lhsOwarnings))+sem_MStat_MStat :: T_Region ->+                   T_Stat ->+                   T_MStat+sem_MStat_MStat pos_ stat_ =+    (case (stat_) of+     { ( _statIcopy,stat_1) ->+         (case (pos_) of+          { ( _posIcopy,_posIidentifier,_posIwarnings) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      MStat _posIcopy _statIcopy+                      {-# LINE 7208 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 7213 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_MStat_MStat_1 :: T_MStat_1+                            sem_MStat_MStat_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 7230 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _statOscopes ->+                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisMeta+                                              {-# LINE 7235 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _statOisMeta ->+                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIisInModule+                                               {-# LINE 7240 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _statOisInModule ->+                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIglobalDefinitions+                                                {-# LINE 7245 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _statOglobalDefinitions ->+                                         (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIconfig+                                                 {-# LINE 7250 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _statOconfig ->+                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIvariableStyle+                                                  {-# LINE 7255 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _statOvariableStyle ->+                                           (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIscopeLevel+                                                   {-# LINE 7260 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _statOscopeLevel ->+                                            (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIloopLevel+                                                    {-# LINE 7265 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _statOloopLevel ->+                                             (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIfuncName+                                                     {-# LINE 7270 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _statOfuncName ->+                                              (case (({-# LINE 309 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _posIcopy+                                                      {-# LINE 7275 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _statOmtokenPos ->+                                               (case (stat_1 _statOconfig _statOfuncName _statOglobalDefinitions _statOisInModule _statOisMeta _statOloopLevel _statOmtokenPos _statOscopeLevel _statOscopes _statOvariableStyle) of+                                                { ( _statIglobalDefinitions,_statIidentifier,_statIisIfStatement,_statIisInModule,_statImtokenPos,_statIscopes,_statIvariableStyle,_statIwarnings) ->+                                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _statIglobalDefinitions+                                                            {-# LINE 7282 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOglobalDefinitions ->+                                                     (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             (const _posIidentifier _statIidentifier)+                                                             {-# LINE 7287 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOidentifier ->+                                                      (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _statIisIfStatement+                                                              {-# LINE 7292 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOisIfStatement ->+                                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _statIisInModule+                                                               {-# LINE 7297 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOisInModule ->+                                                        (case (({-# LINE 308 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _posIcopy+                                                                {-# LINE 7302 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOmtokenPos ->+                                                         (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _statIscopes+                                                                 {-# LINE 7307 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOscopes ->+                                                          (case (({-# LINE 157 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  1+                                                                  {-# LINE 7312 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOstatementCount ->+                                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _statIvariableStyle+                                                                   {-# LINE 7317 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _lhsOvariableStyle ->+                                                            (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _posIwarnings ++ _statIwarnings+                                                                    {-# LINE 7322 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _lhsOwarnings ->+                                                             ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_MStat_MStat_1)) of+                 { ( sem_MStat_1) ->+                 ( _lhsOcopy,sem_MStat_1) }) }) }) }) })+-- MStatList ---------------------------------------------------+-- cata+sem_MStatList :: MStatList ->+                 T_MStatList+sem_MStatList list =+    (Prelude.foldr sem_MStatList_Cons sem_MStatList_Nil (Prelude.map sem_MStat list))+-- semantic domain+type T_MStatList = ( MStatList,T_MStatList_1)+type T_MStatList_1 = LintSettings ->+                     String ->+                     (M.Map String [Region]) ->+                     Bool ->+                     Bool ->+                     Int ->+                     Region ->+                     Int ->+                     ([M.Map String (Bool, Region)]) ->+                     DeterminedVariableStyle ->+                     ( (M.Map String [Region]),String,Bool,Bool,Region,([M.Map String (Bool, Region)]),Int,DeterminedVariableStyle,([String -> LintMessage]))+data Inh_MStatList = Inh_MStatList {config_Inh_MStatList :: LintSettings,funcName_Inh_MStatList :: String,globalDefinitions_Inh_MStatList :: (M.Map String [Region]),isInModule_Inh_MStatList :: Bool,isMeta_Inh_MStatList :: Bool,loopLevel_Inh_MStatList :: Int,mtokenPos_Inh_MStatList :: Region,scopeLevel_Inh_MStatList :: Int,scopes_Inh_MStatList :: ([M.Map String (Bool, Region)]),variableStyle_Inh_MStatList :: DeterminedVariableStyle}+data Syn_MStatList = Syn_MStatList {copy_Syn_MStatList :: MStatList,globalDefinitions_Syn_MStatList :: (M.Map String [Region]),identifier_Syn_MStatList :: String,isIfStatement_Syn_MStatList :: Bool,isInModule_Syn_MStatList :: Bool,mtokenPos_Syn_MStatList :: Region,scopes_Syn_MStatList :: ([M.Map String (Bool, Region)]),statementCount_Syn_MStatList :: Int,variableStyle_Syn_MStatList :: DeterminedVariableStyle,warnings_Syn_MStatList :: ([String -> LintMessage])}+wrap_MStatList :: T_MStatList ->+                  Inh_MStatList ->+                  Syn_MStatList+wrap_MStatList sem (Inh_MStatList _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_MStatList _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisIfStatement _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOstatementCount _lhsOvariableStyle _lhsOwarnings))+sem_MStatList_Cons :: T_MStat ->+                      T_MStatList ->+                      T_MStatList+sem_MStatList_Cons hd_ tl_ =+    (case (tl_) of+     { ( _tlIcopy,tl_1) ->+         (case (hd_) of+          { ( _hdIcopy,hd_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (:) _hdIcopy _tlIcopy+                      {-# LINE 7367 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 7372 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_MStatList_Cons_1 :: T_MStatList_1+                            sem_MStatList_Cons_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 7389 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _hdOscopes ->+                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisMeta+                                              {-# LINE 7394 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _hdOisMeta ->+                                       (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIconfig+                                               {-# LINE 7399 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _hdOconfig ->+                                        (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIvariableStyle+                                                {-# LINE 7404 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _hdOvariableStyle ->+                                         (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIscopeLevel+                                                 {-# LINE 7409 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _hdOscopeLevel ->+                                          (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsImtokenPos+                                                  {-# LINE 7414 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _hdOmtokenPos ->+                                           (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIloopLevel+                                                   {-# LINE 7419 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _hdOloopLevel ->+                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisInModule+                                                    {-# LINE 7424 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _hdOisInModule ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 7429 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _hdOglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 7434 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _hdOfuncName ->+                                               (case (hd_1 _hdOconfig _hdOfuncName _hdOglobalDefinitions _hdOisInModule _hdOisMeta _hdOloopLevel _hdOmtokenPos _hdOscopeLevel _hdOscopes _hdOvariableStyle) of+                                                { ( _hdIglobalDefinitions,_hdIidentifier,_hdIisIfStatement,_hdIisInModule,_hdImtokenPos,_hdIscopes,_hdIstatementCount,_hdIvariableStyle,_hdIwarnings) ->+                                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _hdIscopes+                                                            {-# LINE 7441 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _tlOscopes ->+                                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _lhsIisMeta+                                                             {-# LINE 7446 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _tlOisMeta ->+                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _hdIisInModule+                                                              {-# LINE 7451 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _tlOisInModule ->+                                                       (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _hdIglobalDefinitions+                                                               {-# LINE 7456 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _tlOglobalDefinitions ->+                                                        (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _lhsIconfig+                                                                {-# LINE 7461 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _tlOconfig ->+                                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _hdIvariableStyle+                                                                 {-# LINE 7466 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _tlOvariableStyle ->+                                                          (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIscopeLevel+                                                                  {-# LINE 7471 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _tlOscopeLevel ->+                                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _hdImtokenPos+                                                                   {-# LINE 7476 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _tlOmtokenPos ->+                                                            (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIloopLevel+                                                                    {-# LINE 7481 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _tlOloopLevel ->+                                                             (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _lhsIfuncName+                                                                     {-# LINE 7486 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _tlOfuncName ->+                                                              (case (tl_1 _tlOconfig _tlOfuncName _tlOglobalDefinitions _tlOisInModule _tlOisMeta _tlOloopLevel _tlOmtokenPos _tlOscopeLevel _tlOscopes _tlOvariableStyle) of+                                                               { ( _tlIglobalDefinitions,_tlIidentifier,_tlIisIfStatement,_tlIisInModule,_tlImtokenPos,_tlIscopes,_tlIstatementCount,_tlIvariableStyle,_tlIwarnings) ->+                                                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           _tlIglobalDefinitions+                                                                           {-# LINE 7493 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _lhsOglobalDefinitions ->+                                                                    (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            (const _hdIidentifier _tlIidentifier)+                                                                            {-# LINE 7498 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _lhsOidentifier ->+                                                                     (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _hdIisIfStatement || _tlIisIfStatement+                                                                             {-# LINE 7503 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _lhsOisIfStatement ->+                                                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _tlIisInModule+                                                                              {-# LINE 7508 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _lhsOisInModule ->+                                                                       (case (({-# LINE 234 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _hdImtokenPos+                                                                               {-# LINE 7513 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOmtokenPos ->+                                                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _tlIscopes+                                                                                {-# LINE 7518 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOscopes ->+                                                                         (case (({-# LINE 157 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _hdIstatementCount + _tlIstatementCount+                                                                                 {-# LINE 7523 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOstatementCount ->+                                                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _tlIvariableStyle+                                                                                  {-# LINE 7528 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOvariableStyle ->+                                                                           (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _hdIwarnings ++ _tlIwarnings+                                                                                   {-# LINE 7533 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOwarnings ->+                                                                            ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_MStatList_Cons_1)) of+                 { ( sem_MStatList_1) ->+                 ( _lhsOcopy,sem_MStatList_1) }) }) }) }) })+sem_MStatList_Nil :: T_MStatList+sem_MStatList_Nil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            []+            {-# LINE 7544 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 7549 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_MStatList_Nil_1 :: T_MStatList_1+                  sem_MStatList_Nil_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 7566 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 7571 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     False+                                     {-# LINE 7576 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisIfStatement ->+                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsIisInModule+                                      {-# LINE 7581 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisInModule ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 7586 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 7591 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 240 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         0+                                         {-# LINE 7596 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOstatementCount ->+                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIvariableStyle+                                          {-# LINE 7601 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOvariableStyle ->+                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           []+                                           {-# LINE 7606 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lhsOwarnings ->+                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOstatementCount,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }))+              in  sem_MStatList_Nil_1)) of+       { ( sem_MStatList_1) ->+       ( _lhsOcopy,sem_MStatList_1) }) }) })+-- MToken ------------------------------------------------------+-- cata+sem_MToken :: MToken ->+              T_MToken+sem_MToken (MToken _mpos _mtok) =+    (sem_MToken_MToken (sem_Region _mpos) (sem_Token _mtok))+-- semantic domain+type T_MToken = ( MToken,Token,Region,T_MToken_1)+type T_MToken_1 = LintSettings ->+                  String ->+                  (M.Map String [Region]) ->+                  Bool ->+                  Bool ->+                  Region ->+                  ([M.Map String (Bool, Region)]) ->+                  ( (M.Map String [Region]),String,Bool,([M.Map String (Bool, Region)]),([String -> LintMessage]))+data Inh_MToken = Inh_MToken {config_Inh_MToken :: LintSettings,funcName_Inh_MToken :: String,globalDefinitions_Inh_MToken :: (M.Map String [Region]),isInModule_Inh_MToken :: Bool,isMeta_Inh_MToken :: Bool,mtokenPos_Inh_MToken :: Region,scopes_Inh_MToken :: ([M.Map String (Bool, Region)])}+data Syn_MToken = Syn_MToken {copy_Syn_MToken :: MToken,globalDefinitions_Syn_MToken :: (M.Map String [Region]),identifier_Syn_MToken :: String,isInModule_Syn_MToken :: Bool,mtok_Syn_MToken :: Token,mtokenPos_Syn_MToken :: Region,scopes_Syn_MToken :: ([M.Map String (Bool, Region)]),warnings_Syn_MToken :: ([String -> LintMessage])}+wrap_MToken :: T_MToken ->+               Inh_MToken ->+               Syn_MToken+wrap_MToken sem (Inh_MToken _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsImtokenPos _lhsIscopes) =+    (let ( _lhsOcopy,_lhsOmtok,_lhsOmtokenPos,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOscopes,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsImtokenPos _lhsIscopes+     in  (Syn_MToken _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtok _lhsOmtokenPos _lhsOscopes _lhsOwarnings))+sem_MToken_MToken :: T_Region ->+                     T_Token ->+                     T_MToken+sem_MToken_MToken mpos_ mtok_ =+    (case (mtok_) of+     { ( _mtokIcopy,_mtokIidentifier,_mtokIwarnings) ->+         (case (mpos_) of+          { ( _mposIcopy,_mposIidentifier,_mposIwarnings) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      MToken _mposIcopy _mtokIcopy+                      {-# LINE 7648 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 7653 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case (({-# LINE 227 "src/GLuaFixer/AG/ASTLint.ag" #-}+                        _mtokIcopy+                        {-# LINE 7658 "src/GLuaFixer/AG/ASTLint.hs" #-}+                        )) of+                 { _lhsOmtok ->+                 (case (({-# LINE 226 "src/GLuaFixer/AG/ASTLint.ag" #-}+                         _mposIcopy+                         {-# LINE 7663 "src/GLuaFixer/AG/ASTLint.hs" #-}+                         )) of+                  { _lhsOmtokenPos ->+                  (case ((let sem_MToken_MToken_1 :: T_MToken_1+                              sem_MToken_MToken_1 =+                                  (\ _lhsIconfig+                                     _lhsIfuncName+                                     _lhsIglobalDefinitions+                                     _lhsIisInModule+                                     _lhsIisMeta+                                     _lhsImtokenPos+                                     _lhsIscopes ->+                                       (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIglobalDefinitions+                                               {-# LINE 7677 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _lhsOglobalDefinitions ->+                                        (case (({-# LINE 228 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _mtokIidentifier+                                                {-# LINE 7682 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _lhsOidentifier ->+                                         (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIisInModule+                                                 {-# LINE 7687 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _lhsOisInModule ->+                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIscopes+                                                  {-# LINE 7692 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _lhsOscopes ->+                                           (case (({-# LINE 229 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _mposIwarnings ++ _mtokIwarnings+                                                   {-# LINE 7697 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _warnings_augmented_syn ->+                                            (case (({-# LINE 229 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    if not (lint_goto_identifier _lhsIconfig) || _mtokIidentifier /= "goto" then id else+                                                      (:) $ warn _mposIcopy GotoAsIdentifier+                                                    {-# LINE 7703 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _warnings_augmented_f1 ->+                                             (case (({-# LINE 229 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                     {-# LINE 7708 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _lhsOwarnings ->+                                              ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOscopes,_lhsOwarnings) }) }) }) }) }) }) }))+                          in  sem_MToken_MToken_1)) of+                   { ( sem_MToken_1) ->+                   ( _lhsOcopy,_lhsOmtok,_lhsOmtokenPos,sem_MToken_1) }) }) }) }) }) }) })+-- MTokenList --------------------------------------------------+-- cata+sem_MTokenList :: MTokenList ->+                  T_MTokenList+sem_MTokenList list =+    (Prelude.foldr sem_MTokenList_Cons sem_MTokenList_Nil (Prelude.map sem_MToken list))+-- semantic domain+type T_MTokenList = LintSettings ->+                    String ->+                    (M.Map String [Region]) ->+                    Bool ->+                    Bool ->+                    Region ->+                    ([M.Map String (Bool, Region)]) ->+                    ( MTokenList,(M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),([String -> LintMessage]))+data Inh_MTokenList = Inh_MTokenList {config_Inh_MTokenList :: LintSettings,funcName_Inh_MTokenList :: String,globalDefinitions_Inh_MTokenList :: (M.Map String [Region]),isInModule_Inh_MTokenList :: Bool,isMeta_Inh_MTokenList :: Bool,mtokenPos_Inh_MTokenList :: Region,scopes_Inh_MTokenList :: ([M.Map String (Bool, Region)])}+data Syn_MTokenList = Syn_MTokenList {copy_Syn_MTokenList :: MTokenList,globalDefinitions_Syn_MTokenList :: (M.Map String [Region]),identifier_Syn_MTokenList :: String,isInModule_Syn_MTokenList :: Bool,mtokenPos_Syn_MTokenList :: Region,scopes_Syn_MTokenList :: ([M.Map String (Bool, Region)]),warnings_Syn_MTokenList :: ([String -> LintMessage])}+wrap_MTokenList :: T_MTokenList ->+                   Inh_MTokenList ->+                   Syn_MTokenList+wrap_MTokenList sem (Inh_MTokenList _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsImtokenPos _lhsIscopes) =+    (let ( _lhsOcopy,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOwarnings) = sem _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsImtokenPos _lhsIscopes+     in  (Syn_MTokenList _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOwarnings))+sem_MTokenList_Cons :: T_MToken ->+                       T_MTokenList ->+                       T_MTokenList+sem_MTokenList_Cons hd_ tl_ =+    (\ _lhsIconfig+       _lhsIfuncName+       _lhsIglobalDefinitions+       _lhsIisInModule+       _lhsIisMeta+       _lhsImtokenPos+       _lhsIscopes ->+         (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 _lhsIscopes+                 {-# LINE 7751 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _hdOscopes ->+          (case (hd_) of+           { ( _hdIcopy,_hdImtok,_hdImtokenPos,hd_1) ->+               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _lhsImtokenPos+                       {-# LINE 7758 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _hdOmtokenPos ->+                (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                        _lhsIisMeta+                        {-# LINE 7763 "src/GLuaFixer/AG/ASTLint.hs" #-}+                        )) of+                 { _hdOisMeta ->+                 (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                         _lhsIisInModule+                         {-# LINE 7768 "src/GLuaFixer/AG/ASTLint.hs" #-}+                         )) of+                  { _hdOisInModule ->+                  (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                          _lhsIglobalDefinitions+                          {-# LINE 7773 "src/GLuaFixer/AG/ASTLint.hs" #-}+                          )) of+                   { _hdOglobalDefinitions ->+                   (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                           _lhsIfuncName+                           {-# LINE 7778 "src/GLuaFixer/AG/ASTLint.hs" #-}+                           )) of+                    { _hdOfuncName ->+                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                            _lhsIconfig+                            {-# LINE 7783 "src/GLuaFixer/AG/ASTLint.hs" #-}+                            )) of+                     { _hdOconfig ->+                     (case (hd_1 _hdOconfig _hdOfuncName _hdOglobalDefinitions _hdOisInModule _hdOisMeta _hdOmtokenPos _hdOscopes) of+                      { ( _hdIglobalDefinitions,_hdIidentifier,_hdIisInModule,_hdIscopes,_hdIwarnings) ->+                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                  _hdIscopes+                                  {-# LINE 7790 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                  )) of+                           { _tlOscopes ->+                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _hdImtokenPos+                                   {-# LINE 7795 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _tlOmtokenPos ->+                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    _lhsIisMeta+                                    {-# LINE 7800 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _tlOisMeta ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _hdIisInModule+                                     {-# LINE 7805 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _tlOisInModule ->+                              (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _hdIglobalDefinitions+                                      {-# LINE 7810 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _tlOglobalDefinitions ->+                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIfuncName+                                       {-# LINE 7815 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _tlOfuncName ->+                                (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIconfig+                                        {-# LINE 7820 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _tlOconfig ->+                                 (case (tl_ _tlOconfig _tlOfuncName _tlOglobalDefinitions _tlOisInModule _tlOisMeta _tlOmtokenPos _tlOscopes) of+                                  { ( _tlIcopy,_tlIglobalDefinitions,_tlIidentifier,_tlIisInModule,_tlImtokenPos,_tlIscopes,_tlIwarnings) ->+                                      (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              (:) _hdIcopy _tlIcopy+                                              {-# LINE 7827 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _copy ->+                                       (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _copy+                                               {-# LINE 7832 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _lhsOcopy ->+                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _tlIglobalDefinitions+                                                {-# LINE 7837 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _lhsOglobalDefinitions ->+                                         (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 (const _hdIidentifier _tlIidentifier)+                                                 {-# LINE 7842 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _lhsOidentifier ->+                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _tlIisInModule+                                                  {-# LINE 7847 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _lhsOisInModule ->+                                           (case (({-# LINE 234 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _hdImtokenPos+                                                   {-# LINE 7852 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _lhsOmtokenPos ->+                                            (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _tlIscopes+                                                    {-# LINE 7857 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _lhsOscopes ->+                                             (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _hdIwarnings ++ _tlIwarnings+                                                     {-# LINE 7862 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _lhsOwarnings ->+                                              ( _lhsOcopy,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_MTokenList_Nil :: T_MTokenList+sem_MTokenList_Nil =+    (\ _lhsIconfig+       _lhsIfuncName+       _lhsIglobalDefinitions+       _lhsIisInModule+       _lhsIisMeta+       _lhsImtokenPos+       _lhsIscopes ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 []+                 {-# LINE 7877 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 7882 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                   _lhsIglobalDefinitions+                   {-# LINE 7887 "src/GLuaFixer/AG/ASTLint.hs" #-}+                   )) of+            { _lhsOglobalDefinitions ->+            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                    unknownIdentifier+                    {-# LINE 7892 "src/GLuaFixer/AG/ASTLint.hs" #-}+                    )) of+             { _lhsOidentifier ->+             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                     _lhsIisInModule+                     {-# LINE 7897 "src/GLuaFixer/AG/ASTLint.hs" #-}+                     )) of+              { _lhsOisInModule ->+              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      _lhsImtokenPos+                      {-# LINE 7902 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _lhsOmtokenPos ->+               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _lhsIscopes+                       {-# LINE 7907 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOscopes ->+                (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                        []+                        {-# LINE 7912 "src/GLuaFixer/AG/ASTLint.hs" #-}+                        )) of+                 { _lhsOwarnings ->+                 ( _lhsOcopy,_lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOwarnings) }) }) }) }) }) }) }) }))+-- MaybeMExpr --------------------------------------------------+-- cata+sem_MaybeMExpr :: MaybeMExpr ->+                  T_MaybeMExpr+sem_MaybeMExpr (Prelude.Just x) =+    (sem_MaybeMExpr_Just (sem_MExpr x))+sem_MaybeMExpr Prelude.Nothing =+    sem_MaybeMExpr_Nothing+-- semantic domain+type T_MaybeMExpr = ( MaybeMExpr,T_MaybeMExpr_1)+type T_MaybeMExpr_1 = LintSettings ->+                      String ->+                      (M.Map String [Region]) ->+                      Bool ->+                      Bool ->+                      Bool ->+                      Int ->+                      Region ->+                      Int ->+                      ([M.Map String (Bool, Region)]) ->+                      (Maybe MToken) ->+                      DeterminedVariableStyle ->+                      ( (M.Map String [Region]),String,Bool,(Maybe MToken),Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_MaybeMExpr = Inh_MaybeMExpr {config_Inh_MaybeMExpr :: LintSettings,funcName_Inh_MaybeMExpr :: String,globalDefinitions_Inh_MaybeMExpr :: (M.Map String [Region]),isInModule_Inh_MaybeMExpr :: Bool,isMeta_Inh_MaybeMExpr :: Bool,isNegation_Inh_MaybeMExpr :: Bool,loopLevel_Inh_MaybeMExpr :: Int,mtokenPos_Inh_MaybeMExpr :: Region,scopeLevel_Inh_MaybeMExpr :: Int,scopes_Inh_MaybeMExpr :: ([M.Map String (Bool, Region)]),varBeingDefined_Inh_MaybeMExpr :: (Maybe MToken),variableStyle_Inh_MaybeMExpr :: DeterminedVariableStyle}+data Syn_MaybeMExpr = Syn_MaybeMExpr {copy_Syn_MaybeMExpr :: MaybeMExpr,globalDefinitions_Syn_MaybeMExpr :: (M.Map String [Region]),identifier_Syn_MaybeMExpr :: String,isInModule_Syn_MaybeMExpr :: Bool,isSingleVar_Syn_MaybeMExpr :: (Maybe MToken),mtokenPos_Syn_MaybeMExpr :: Region,scopes_Syn_MaybeMExpr :: ([M.Map String (Bool, Region)]),variableStyle_Syn_MaybeMExpr :: DeterminedVariableStyle,warnings_Syn_MaybeMExpr :: ([String -> LintMessage])}+wrap_MaybeMExpr :: T_MaybeMExpr ->+                   Inh_MaybeMExpr ->+                   Syn_MaybeMExpr+wrap_MaybeMExpr sem (Inh_MaybeMExpr _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIisNegation _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvarBeingDefined _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIisNegation _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvarBeingDefined _lhsIvariableStyle+     in  (Syn_MaybeMExpr _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOisSingleVar _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_MaybeMExpr_Just :: T_MExpr ->+                       T_MaybeMExpr+sem_MaybeMExpr_Just just_ =+    (case (just_) of+     { ( _justIcopy,_justImtokenPos,just_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 Just _justIcopy+                 {-# LINE 7955 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 7960 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_MaybeMExpr_Just_1 :: T_MaybeMExpr_1+                       sem_MaybeMExpr_Just_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIisNegation+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvarBeingDefined+                              _lhsIvariableStyle ->+                                (case (({-# LINE 178 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvarBeingDefined+                                        {-# LINE 7979 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _justOvarBeingDefined ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 7984 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _justOscopes ->+                                  (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisMeta+                                          {-# LINE 7989 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _justOisMeta ->+                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIisInModule+                                           {-# LINE 7994 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _justOisInModule ->+                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIglobalDefinitions+                                            {-# LINE 7999 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _justOglobalDefinitions ->+                                     (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIconfig+                                             {-# LINE 8004 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _justOconfig ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 8009 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _justOvariableStyle ->+                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopeLevel+                                               {-# LINE 8014 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _justOscopeLevel ->+                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsImtokenPos+                                                {-# LINE 8019 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _justOmtokenPos ->+                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIloopLevel+                                                 {-# LINE 8024 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _justOloopLevel ->+                                          (case (({-# LINE 169 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIisNegation+                                                  {-# LINE 8029 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _justOisNegation ->+                                           (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIfuncName+                                                   {-# LINE 8034 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _justOfuncName ->+                                            (case (({-# LINE 251 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    False+                                                    {-# LINE 8039 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _justOtopLevel ->+                                             (case (({-# LINE 250 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     False+                                                     {-# LINE 8044 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _justOinParentheses ->+                                              (case (just_1 _justOconfig _justOfuncName _justOglobalDefinitions _justOinParentheses _justOisInModule _justOisMeta _justOisNegation _justOloopLevel _justOmtokenPos _justOscopeLevel _justOscopes _justOtopLevel _justOvarBeingDefined _justOvariableStyle) of+                                               { ( _justIglobalDefinitions,_justIidentifier,_justIisInModule,_justIisSimpleExpression,_justIisSingleVar,_justIscopes,_justIvariableStyle,_justIwarnings) ->+                                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _justIglobalDefinitions+                                                           {-# LINE 8051 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOglobalDefinitions ->+                                                    (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _justIidentifier+                                                            {-# LINE 8056 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOidentifier ->+                                                     (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _justIisInModule+                                                             {-# LINE 8061 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOisInModule ->+                                                      (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _justIisSingleVar+                                                              {-# LINE 8066 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOisSingleVar ->+                                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _justImtokenPos+                                                               {-# LINE 8071 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOmtokenPos ->+                                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _justIscopes+                                                                {-# LINE 8076 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOscopes ->+                                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _justIvariableStyle+                                                                 {-# LINE 8081 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOvariableStyle ->+                                                          (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _justIwarnings+                                                                  {-# LINE 8086 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOwarnings ->+                                                           ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_MaybeMExpr_Just_1)) of+            { ( sem_MaybeMExpr_1) ->+            ( _lhsOcopy,sem_MaybeMExpr_1) }) }) }) })+sem_MaybeMExpr_Nothing :: T_MaybeMExpr+sem_MaybeMExpr_Nothing =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Nothing+            {-# LINE 8097 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 8102 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_MaybeMExpr_Nothing_1 :: T_MaybeMExpr_1+                  sem_MaybeMExpr_Nothing_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIisNegation+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvarBeingDefined+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 8121 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 8126 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 8131 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 213 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      Nothing+                                      {-# LINE 8136 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisSingleVar ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 8141 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 8146 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 8151 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 8156 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSingleVar,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_MaybeMExpr_Nothing_1)) of+       { ( sem_MaybeMExpr_1) ->+       ( _lhsOcopy,sem_MaybeMExpr_1) }) }) })+-- PFExprSuffix ------------------------------------------------+-- cata+sem_PFExprSuffix :: PFExprSuffix ->+                    T_PFExprSuffix+sem_PFExprSuffix (Call _args) =+    (sem_PFExprSuffix_Call (sem_Args _args))+sem_PFExprSuffix (MetaCall _fn _args) =+    (sem_PFExprSuffix_MetaCall (sem_MToken _fn) (sem_Args _args))+sem_PFExprSuffix (ExprIndex _index) =+    (sem_PFExprSuffix_ExprIndex (sem_MExpr _index))+sem_PFExprSuffix (DotIndex _index) =+    (sem_PFExprSuffix_DotIndex (sem_MToken _index))+-- semantic domain+type T_PFExprSuffix = ( PFExprSuffix,T_PFExprSuffix_1)+type T_PFExprSuffix_1 = LintSettings ->+                        String ->+                        (M.Map String [Region]) ->+                        Bool ->+                        Bool ->+                        Int ->+                        Region ->+                        Int ->+                        ([M.Map String (Bool, Region)]) ->+                        DeterminedVariableStyle ->+                        ( (M.Map String [Region]),String,Bool,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_PFExprSuffix = Inh_PFExprSuffix {config_Inh_PFExprSuffix :: LintSettings,funcName_Inh_PFExprSuffix :: String,globalDefinitions_Inh_PFExprSuffix :: (M.Map String [Region]),isInModule_Inh_PFExprSuffix :: Bool,isMeta_Inh_PFExprSuffix :: Bool,loopLevel_Inh_PFExprSuffix :: Int,mtokenPos_Inh_PFExprSuffix :: Region,scopeLevel_Inh_PFExprSuffix :: Int,scopes_Inh_PFExprSuffix :: ([M.Map String (Bool, Region)]),variableStyle_Inh_PFExprSuffix :: DeterminedVariableStyle}+data Syn_PFExprSuffix = Syn_PFExprSuffix {copy_Syn_PFExprSuffix :: PFExprSuffix,globalDefinitions_Syn_PFExprSuffix :: (M.Map String [Region]),identifier_Syn_PFExprSuffix :: String,isInModule_Syn_PFExprSuffix :: Bool,isSimpleExpression_Syn_PFExprSuffix :: Bool,mtokenPos_Syn_PFExprSuffix :: Region,scopes_Syn_PFExprSuffix :: ([M.Map String (Bool, Region)]),variableStyle_Syn_PFExprSuffix :: DeterminedVariableStyle,warnings_Syn_PFExprSuffix :: ([String -> LintMessage])}+wrap_PFExprSuffix :: T_PFExprSuffix ->+                     Inh_PFExprSuffix ->+                     Syn_PFExprSuffix+wrap_PFExprSuffix sem (Inh_PFExprSuffix _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_PFExprSuffix _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOisSimpleExpression _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_PFExprSuffix_Call :: T_Args ->+                         T_PFExprSuffix+sem_PFExprSuffix_Call args_ =+    (case (args_) of+     { ( _argsIcopy,args_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 Call _argsIcopy+                 {-# LINE 8204 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 8209 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_PFExprSuffix_Call_1 :: T_PFExprSuffix_1+                       sem_PFExprSuffix_Call_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 8226 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _argsOscopes ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 8231 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _argsOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 8236 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _argsOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 8241 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _argsOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 8246 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _argsOconfig ->+                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIvariableStyle+                                             {-# LINE 8251 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _argsOvariableStyle ->+                                      (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIscopeLevel+                                              {-# LINE 8256 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _argsOscopeLevel ->+                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsImtokenPos+                                               {-# LINE 8261 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _argsOmtokenPos ->+                                        (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIloopLevel+                                                {-# LINE 8266 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _argsOloopLevel ->+                                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIfuncName+                                                 {-# LINE 8271 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _argsOfuncName ->+                                          (case (args_1 _argsOconfig _argsOfuncName _argsOglobalDefinitions _argsOisInModule _argsOisMeta _argsOloopLevel _argsOmtokenPos _argsOscopeLevel _argsOscopes _argsOvariableStyle) of+                                           { ( _argsIglobalDefinitions,_argsIidentifier,_argsIisInModule,_argsImtokenPos,_argsIscopes,_argsIvariableStyle,_argsIwarnings) ->+                                               (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _argsIglobalDefinitions+                                                       {-# LINE 8278 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _lhsOglobalDefinitions ->+                                                (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _argsIidentifier+                                                        {-# LINE 8283 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOidentifier ->+                                                 (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _argsIisInModule+                                                         {-# LINE 8288 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOisInModule ->+                                                  (case (({-# LINE 545 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          False+                                                          {-# LINE 8293 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOisSimpleExpression ->+                                                   (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _argsImtokenPos+                                                           {-# LINE 8298 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOmtokenPos ->+                                                    (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _argsIscopes+                                                            {-# LINE 8303 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOscopes ->+                                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _argsIvariableStyle+                                                             {-# LINE 8308 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOvariableStyle ->+                                                      (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _argsIwarnings+                                                              {-# LINE 8313 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOwarnings ->+                                                       ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_PFExprSuffix_Call_1)) of+            { ( sem_PFExprSuffix_1) ->+            ( _lhsOcopy,sem_PFExprSuffix_1) }) }) }) })+sem_PFExprSuffix_MetaCall :: T_MToken ->+                             T_Args ->+                             T_PFExprSuffix+sem_PFExprSuffix_MetaCall fn_ args_ =+    (case (args_) of+     { ( _argsIcopy,args_1) ->+         (case (fn_) of+          { ( _fnIcopy,_fnImtok,_fnImtokenPos,fn_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      MetaCall _fnIcopy _argsIcopy+                      {-# LINE 8330 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 8335 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_PFExprSuffix_MetaCall_1 :: T_PFExprSuffix_1+                            sem_PFExprSuffix_MetaCall_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 8352 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _fnOscopes ->+                                      (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsImtokenPos+                                              {-# LINE 8357 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _fnOmtokenPos ->+                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIisMeta+                                               {-# LINE 8362 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _fnOisMeta ->+                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIisInModule+                                                {-# LINE 8367 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _fnOisInModule ->+                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIglobalDefinitions+                                                 {-# LINE 8372 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _fnOglobalDefinitions ->+                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIfuncName+                                                  {-# LINE 8377 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _fnOfuncName ->+                                           (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIconfig+                                                   {-# LINE 8382 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _fnOconfig ->+                                            (case (fn_1 _fnOconfig _fnOfuncName _fnOglobalDefinitions _fnOisInModule _fnOisMeta _fnOmtokenPos _fnOscopes) of+                                             { ( _fnIglobalDefinitions,_fnIidentifier,_fnIisInModule,_fnIscopes,_fnIwarnings) ->+                                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _fnIscopes+                                                         {-# LINE 8389 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _argsOscopes ->+                                                  (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIisMeta+                                                          {-# LINE 8394 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _argsOisMeta ->+                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _fnIisInModule+                                                           {-# LINE 8399 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _argsOisInModule ->+                                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _fnIglobalDefinitions+                                                            {-# LINE 8404 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _argsOglobalDefinitions ->+                                                     (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _lhsIconfig+                                                             {-# LINE 8409 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _argsOconfig ->+                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _lhsIvariableStyle+                                                              {-# LINE 8414 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _argsOvariableStyle ->+                                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _lhsIscopeLevel+                                                               {-# LINE 8419 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _argsOscopeLevel ->+                                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _fnImtokenPos+                                                                {-# LINE 8424 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _argsOmtokenPos ->+                                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _lhsIloopLevel+                                                                 {-# LINE 8429 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _argsOloopLevel ->+                                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIfuncName+                                                                  {-# LINE 8434 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _argsOfuncName ->+                                                           (case (args_1 _argsOconfig _argsOfuncName _argsOglobalDefinitions _argsOisInModule _argsOisMeta _argsOloopLevel _argsOmtokenPos _argsOscopeLevel _argsOscopes _argsOvariableStyle) of+                                                            { ( _argsIglobalDefinitions,_argsIidentifier,_argsIisInModule,_argsImtokenPos,_argsIscopes,_argsIvariableStyle,_argsIwarnings) ->+                                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _argsIglobalDefinitions+                                                                        {-# LINE 8441 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _lhsOglobalDefinitions ->+                                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         (const _fnIidentifier _argsIidentifier)+                                                                         {-# LINE 8446 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _lhsOidentifier ->+                                                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _argsIisInModule+                                                                          {-# LINE 8451 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _lhsOisInModule ->+                                                                   (case (({-# LINE 547 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           False+                                                                           {-# LINE 8456 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _lhsOisSimpleExpression ->+                                                                    (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            _argsImtokenPos+                                                                            {-# LINE 8461 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _lhsOmtokenPos ->+                                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _argsIscopes+                                                                             {-# LINE 8466 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _lhsOscopes ->+                                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _argsIvariableStyle+                                                                              {-# LINE 8471 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _lhsOvariableStyle ->+                                                                       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _fnIwarnings ++ _argsIwarnings+                                                                               {-# LINE 8476 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOwarnings ->+                                                                        ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_PFExprSuffix_MetaCall_1)) of+                 { ( sem_PFExprSuffix_1) ->+                 ( _lhsOcopy,sem_PFExprSuffix_1) }) }) }) }) })+sem_PFExprSuffix_ExprIndex :: T_MExpr ->+                              T_PFExprSuffix+sem_PFExprSuffix_ExprIndex index_ =+    (case (index_) of+     { ( _indexIcopy,_indexImtokenPos,index_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 ExprIndex _indexIcopy+                 {-# LINE 8490 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 8495 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_PFExprSuffix_ExprIndex_1 :: T_PFExprSuffix_1+                       sem_PFExprSuffix_ExprIndex_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 8512 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _indexOscopes ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 8517 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _indexOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 8522 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _indexOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 8527 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _indexOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 8532 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _indexOconfig ->+                                     (case (({-# LINE 552 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             Nothing+                                             {-# LINE 8537 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _indexOvarBeingDefined ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 8542 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _indexOvariableStyle ->+                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopeLevel+                                               {-# LINE 8547 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _indexOscopeLevel ->+                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsImtokenPos+                                                {-# LINE 8552 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _indexOmtokenPos ->+                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIloopLevel+                                                 {-# LINE 8557 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _indexOloopLevel ->+                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIfuncName+                                                  {-# LINE 8562 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _indexOfuncName ->+                                           (case (({-# LINE 551 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   True+                                                   {-# LINE 8567 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _indexOtopLevel ->+                                            (case (({-# LINE 550 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    True+                                                    {-# LINE 8572 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _indexOinParentheses ->+                                             (case (({-# LINE 549 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     False+                                                     {-# LINE 8577 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _indexOisNegation ->+                                              (case (index_1 _indexOconfig _indexOfuncName _indexOglobalDefinitions _indexOinParentheses _indexOisInModule _indexOisMeta _indexOisNegation _indexOloopLevel _indexOmtokenPos _indexOscopeLevel _indexOscopes _indexOtopLevel _indexOvarBeingDefined _indexOvariableStyle) of+                                               { ( _indexIglobalDefinitions,_indexIidentifier,_indexIisInModule,_indexIisSimpleExpression,_indexIisSingleVar,_indexIscopes,_indexIvariableStyle,_indexIwarnings) ->+                                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _indexIglobalDefinitions+                                                           {-# LINE 8584 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOglobalDefinitions ->+                                                    (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _indexIidentifier+                                                            {-# LINE 8589 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOidentifier ->+                                                     (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _indexIisInModule+                                                             {-# LINE 8594 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOisInModule ->+                                                      (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _indexIisSimpleExpression+                                                              {-# LINE 8599 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOisSimpleExpression ->+                                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _indexImtokenPos+                                                               {-# LINE 8604 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOmtokenPos ->+                                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _indexIscopes+                                                                {-# LINE 8609 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOscopes ->+                                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _indexIvariableStyle+                                                                 {-# LINE 8614 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOvariableStyle ->+                                                          (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _indexIwarnings+                                                                  {-# LINE 8619 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOwarnings ->+                                                           ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_PFExprSuffix_ExprIndex_1)) of+            { ( sem_PFExprSuffix_1) ->+            ( _lhsOcopy,sem_PFExprSuffix_1) }) }) }) })+sem_PFExprSuffix_DotIndex :: T_MToken ->+                             T_PFExprSuffix+sem_PFExprSuffix_DotIndex index_ =+    (case (index_) of+     { ( _indexIcopy,_indexImtok,_indexImtokenPos,index_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 DotIndex _indexIcopy+                 {-# LINE 8633 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 8638 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_PFExprSuffix_DotIndex_1 :: T_PFExprSuffix_1+                       sem_PFExprSuffix_DotIndex_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIglobalDefinitions+                                        {-# LINE 8655 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _indexOglobalDefinitions ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 8660 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _indexOscopes ->+                                  (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsImtokenPos+                                          {-# LINE 8665 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _indexOmtokenPos ->+                                   (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIisMeta+                                           {-# LINE 8670 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _indexOisMeta ->+                                    (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIisInModule+                                            {-# LINE 8675 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _indexOisInModule ->+                                     (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIfuncName+                                             {-# LINE 8680 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _indexOfuncName ->+                                      (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIconfig+                                              {-# LINE 8685 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _indexOconfig ->+                                       (case (index_1 _indexOconfig _indexOfuncName _indexOglobalDefinitions _indexOisInModule _indexOisMeta _indexOmtokenPos _indexOscopes) of+                                        { ( _indexIglobalDefinitions,_indexIidentifier,_indexIisInModule,_indexIscopes,_indexIwarnings) ->+                                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _indexIglobalDefinitions+                                                    {-# LINE 8692 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _lhsOglobalDefinitions ->+                                             (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _indexIidentifier+                                                     {-# LINE 8697 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _lhsOidentifier ->+                                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _indexIisInModule+                                                      {-# LINE 8702 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _lhsOisInModule ->+                                               (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       True+                                                       {-# LINE 8707 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _lhsOisSimpleExpression ->+                                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _indexImtokenPos+                                                        {-# LINE 8712 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOmtokenPos ->+                                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _indexIscopes+                                                         {-# LINE 8717 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOscopes ->+                                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIvariableStyle+                                                          {-# LINE 8722 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOvariableStyle ->+                                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _indexIwarnings+                                                           {-# LINE 8727 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOwarnings ->+                                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_PFExprSuffix_DotIndex_1)) of+            { ( sem_PFExprSuffix_1) ->+            ( _lhsOcopy,sem_PFExprSuffix_1) }) }) }) })+-- PrefixExp ---------------------------------------------------+-- cata+sem_PrefixExp :: PrefixExp ->+                 T_PrefixExp+sem_PrefixExp (PFVar _name _suffixes) =+    (sem_PrefixExp_PFVar (sem_MToken _name) (sem_ExprSuffixList _suffixes))+sem_PrefixExp (ExprVar _expr _suffixes) =+    (sem_PrefixExp_ExprVar (sem_MExpr _expr) (sem_ExprSuffixList _suffixes))+-- semantic domain+type T_PrefixExp = ( PrefixExp,Bool,Region,(Maybe MToken),T_PrefixExp_1)+type T_PrefixExp_1 = LintSettings ->+                     String ->+                     (M.Map String [Region]) ->+                     Bool ->+                     Bool ->+                     Bool ->+                     Bool ->+                     Int ->+                     Region ->+                     Bool ->+                     Int ->+                     ([M.Map String (Bool, Region)]) ->+                     Bool ->+                     (Maybe MToken) ->+                     DeterminedVariableStyle ->+                     ( (M.Map String [Region]),String,Bool,Bool,(Maybe MToken),([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_PrefixExp = Inh_PrefixExp {config_Inh_PrefixExp :: LintSettings,funcName_Inh_PrefixExp :: String,globalDefinitions_Inh_PrefixExp :: (M.Map String [Region]),inParentheses_Inh_PrefixExp :: Bool,isInModule_Inh_PrefixExp :: Bool,isMeta_Inh_PrefixExp :: Bool,isNegation_Inh_PrefixExp :: Bool,loopLevel_Inh_PrefixExp :: Int,mtokenPos_Inh_PrefixExp :: Region,registerVarUse_Inh_PrefixExp :: Bool,scopeLevel_Inh_PrefixExp :: Int,scopes_Inh_PrefixExp :: ([M.Map String (Bool, Region)]),topLevel_Inh_PrefixExp :: Bool,varBeingDefined_Inh_PrefixExp :: (Maybe MToken),variableStyle_Inh_PrefixExp :: DeterminedVariableStyle}+data Syn_PrefixExp = Syn_PrefixExp {copy_Syn_PrefixExp :: PrefixExp,globalDefinitions_Syn_PrefixExp :: (M.Map String [Region]),hasSuffixes_Syn_PrefixExp :: Bool,identifier_Syn_PrefixExp :: String,isInModule_Syn_PrefixExp :: Bool,isSimpleExpression_Syn_PrefixExp :: Bool,isSingleVar_Syn_PrefixExp :: (Maybe MToken),mtokenPos_Syn_PrefixExp :: Region,scopes_Syn_PrefixExp :: ([M.Map String (Bool, Region)]),varName_Syn_PrefixExp :: (Maybe MToken),variableStyle_Syn_PrefixExp :: DeterminedVariableStyle,warnings_Syn_PrefixExp :: ([String -> LintMessage])}+wrap_PrefixExp :: T_PrefixExp ->+                  Inh_PrefixExp ->+                  Syn_PrefixExp+wrap_PrefixExp sem (Inh_PrefixExp _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIinParentheses _lhsIisInModule _lhsIisMeta _lhsIisNegation _lhsIloopLevel _lhsImtokenPos _lhsIregisterVarUse _lhsIscopeLevel _lhsIscopes _lhsItopLevel _lhsIvarBeingDefined _lhsIvariableStyle) =+    (let ( _lhsOcopy,_lhsOhasSuffixes,_lhsOmtokenPos,_lhsOvarName,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIinParentheses _lhsIisInModule _lhsIisMeta _lhsIisNegation _lhsIloopLevel _lhsImtokenPos _lhsIregisterVarUse _lhsIscopeLevel _lhsIscopes _lhsItopLevel _lhsIvarBeingDefined _lhsIvariableStyle+     in  (Syn_PrefixExp _lhsOcopy _lhsOglobalDefinitions _lhsOhasSuffixes _lhsOidentifier _lhsOisInModule _lhsOisSimpleExpression _lhsOisSingleVar _lhsOmtokenPos _lhsOscopes _lhsOvarName _lhsOvariableStyle _lhsOwarnings))+sem_PrefixExp_PFVar :: T_MToken ->+                       T_ExprSuffixList ->+                       T_PrefixExp+sem_PrefixExp_PFVar name_ suffixes_ =+    (case (suffixes_) of+     { ( _suffixesIcopy,suffixes_1) ->+         (case (name_) of+          { ( _nameIcopy,_nameImtok,_nameImtokenPos,name_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      PFVar _nameIcopy _suffixesIcopy+                      {-# LINE 8779 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 8784 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case (({-# LINE 507 "src/GLuaFixer/AG/ASTLint.ag" #-}+                        not . null $ _suffixesIcopy+                        {-# LINE 8789 "src/GLuaFixer/AG/ASTLint.hs" #-}+                        )) of+                 { _lhsOhasSuffixes ->+                 (case (({-# LINE 506 "src/GLuaFixer/AG/ASTLint.ag" #-}+                         _nameImtokenPos+                         {-# LINE 8794 "src/GLuaFixer/AG/ASTLint.hs" #-}+                         )) of+                  { _lhsOmtokenPos ->+                  (case (({-# LINE 509 "src/GLuaFixer/AG/ASTLint.ag" #-}+                          Just _nameIcopy+                          {-# LINE 8799 "src/GLuaFixer/AG/ASTLint.hs" #-}+                          )) of+                   { _varName ->+                   (case (({-# LINE 192 "src/GLuaFixer/AG/ASTLint.ag" #-}+                           _varName+                           {-# LINE 8804 "src/GLuaFixer/AG/ASTLint.hs" #-}+                           )) of+                    { _lhsOvarName ->+                    (case ((let sem_PrefixExp_PFVar_1 :: T_PrefixExp_1+                                sem_PrefixExp_PFVar_1 =+                                    (\ _lhsIconfig+                                       _lhsIfuncName+                                       _lhsIglobalDefinitions+                                       _lhsIinParentheses+                                       _lhsIisInModule+                                       _lhsIisMeta+                                       _lhsIisNegation+                                       _lhsIloopLevel+                                       _lhsImtokenPos+                                       _lhsIregisterVarUse+                                       _lhsIscopeLevel+                                       _lhsIscopes+                                       _lhsItopLevel+                                       _lhsIvarBeingDefined+                                       _lhsIvariableStyle ->+                                         (case (({-# LINE 513 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 if isJust _lhsIvarBeingDefined && _lhsIvarBeingDefined == _varName     then+                                                   case _lhsIscopes of+                                                     deepestScope : otherScopes -> deepestScope : registerVariable otherScopes _nameImtokenPos (show _nameImtok) _lhsIregisterVarUse+                                                     noScopes -> noScopes+                                                 else+                                                   registerVariable _lhsIscopes _nameImtokenPos (show _nameImtok) _lhsIregisterVarUse+                                                 {-# LINE 8831 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _foundVars ->+                                          (case (({-# LINE 523 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _foundVars+                                                  {-# LINE 8836 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _nameOscopes ->+                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsImtokenPos+                                                   {-# LINE 8841 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _nameOmtokenPos ->+                                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisMeta+                                                    {-# LINE 8846 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _nameOisMeta ->+                                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIisInModule+                                                     {-# LINE 8851 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _nameOisInModule ->+                                              (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIglobalDefinitions+                                                      {-# LINE 8856 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _nameOglobalDefinitions ->+                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIfuncName+                                                       {-# LINE 8861 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _nameOfuncName ->+                                                (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIconfig+                                                        {-# LINE 8866 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _nameOconfig ->+                                                 (case (name_1 _nameOconfig _nameOfuncName _nameOglobalDefinitions _nameOisInModule _nameOisMeta _nameOmtokenPos _nameOscopes) of+                                                  { ( _nameIglobalDefinitions,_nameIidentifier,_nameIisInModule,_nameIscopes,_nameIwarnings) ->+                                                      (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _nameIscopes+                                                              {-# LINE 8873 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _suffixesOscopes ->+                                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _lhsIisMeta+                                                               {-# LINE 8878 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _suffixesOisMeta ->+                                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _nameIisInModule+                                                                {-# LINE 8883 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _suffixesOisInModule ->+                                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _nameIglobalDefinitions+                                                                 {-# LINE 8888 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _suffixesOglobalDefinitions ->+                                                          (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIconfig+                                                                  {-# LINE 8893 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _suffixesOconfig ->+                                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIvariableStyle+                                                                   {-# LINE 8898 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _suffixesOvariableStyle ->+                                                            (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIscopeLevel+                                                                    {-# LINE 8903 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _suffixesOscopeLevel ->+                                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _nameImtokenPos+                                                                     {-# LINE 8908 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _suffixesOmtokenPos ->+                                                              (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIloopLevel+                                                                      {-# LINE 8913 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _suffixesOloopLevel ->+                                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIfuncName+                                                                       {-# LINE 8918 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _suffixesOfuncName ->+                                                                (case (suffixes_1 _suffixesOconfig _suffixesOfuncName _suffixesOglobalDefinitions _suffixesOisInModule _suffixesOisMeta _suffixesOloopLevel _suffixesOmtokenPos _suffixesOscopeLevel _suffixesOscopes _suffixesOvariableStyle) of+                                                                 { ( _suffixesIglobalDefinitions,_suffixesIidentifier,_suffixesIisInModule,_suffixesIisSimpleExpression,_suffixesImtokenPos,_suffixesIscopes,_suffixesIvariableStyle,_suffixesIwarnings) ->+                                                                     (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _suffixesIglobalDefinitions+                                                                             {-# LINE 8925 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _lhsOglobalDefinitions ->+                                                                      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              (const _nameIidentifier _suffixesIidentifier)+                                                                              {-# LINE 8930 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _lhsOidentifier ->+                                                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _suffixesIisInModule+                                                                               {-# LINE 8935 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOisInModule ->+                                                                        (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _suffixesIisSimpleExpression+                                                                                {-# LINE 8940 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOisSimpleExpression ->+                                                                         (case (({-# LINE 508 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 if null _suffixesIcopy then _varName     else Nothing+                                                                                 {-# LINE 8945 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOisSingleVar ->+                                                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _suffixesIscopes+                                                                                  {-# LINE 8950 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOscopes ->+                                                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _suffixesIvariableStyle+                                                                                   {-# LINE 8955 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOvariableStyle ->+                                                                            (case (({-# LINE 529 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _nameIwarnings ++ _suffixesIwarnings+                                                                                    {-# LINE 8960 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _warnings_augmented_syn ->+                                                                             (case (({-# LINE 522 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     tokenLabel _nameIcopy+                                                                                     {-# LINE 8965 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _name ->+                                                                              (case (({-# LINE 529 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      if not (lint_beginnerMistakes _lhsIconfig) || _lhsIisMeta || _name     /= "self" then id else+                                                                                        (:) $ warn _nameImtokenPos SelfInNonMeta+                                                                                      {-# LINE 8971 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _warnings_augmented_f3 ->+                                                                               (case (({-# LINE 529 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       if not (lint_beginnerMistakes _lhsIconfig) || not _lhsIisMeta || _name     /= "self" ||+                                                                                       _lhsIfuncName /= "ENT" || _suffixesIidentifier /= "Entity" then id else+                                                                                         (:) $ warn _nameImtokenPos SelfEntity+                                                                                       {-# LINE 8978 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _warnings_augmented_f2 ->+                                                                                (case (({-# LINE 529 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        if not (lint_beginnerMistakes _lhsIconfig) || not _lhsIisMeta || _name     /= "self" ||+                                                                                        _lhsIfuncName /= "SWEP" || _suffixesIidentifier /= "Weapon" then id else+                                                                                          (:) $ warn _nameImtokenPos SelfWeapon+                                                                                        {-# LINE 8985 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _warnings_augmented_f1 ->+                                                                                 (case (({-# LINE 529 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         foldr ($) _warnings_augmented_syn [_warnings_augmented_f1, _warnings_augmented_f2, _warnings_augmented_f3]+                                                                                         {-# LINE 8990 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _lhsOwarnings ->+                                                                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                            in  sem_PrefixExp_PFVar_1)) of+                     { ( sem_PrefixExp_1) ->+                     ( _lhsOcopy,_lhsOhasSuffixes,_lhsOmtokenPos,_lhsOvarName,sem_PrefixExp_1) }) }) }) }) }) }) }) }) })+sem_PrefixExp_ExprVar :: T_MExpr ->+                         T_ExprSuffixList ->+                         T_PrefixExp+sem_PrefixExp_ExprVar expr_ suffixes_ =+    (case (suffixes_) of+     { ( _suffixesIcopy,suffixes_1) ->+         (case (expr_) of+          { ( _exprIcopy,_exprImtokenPos,expr_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      ExprVar _exprIcopy _suffixesIcopy+                      {-# LINE 9007 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 9012 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case (({-# LINE 536 "src/GLuaFixer/AG/ASTLint.ag" #-}+                        False+                        {-# LINE 9017 "src/GLuaFixer/AG/ASTLint.hs" #-}+                        )) of+                 { _lhsOhasSuffixes ->+                 (case (({-# LINE 533 "src/GLuaFixer/AG/ASTLint.ag" #-}+                         _exprImtokenPos+                         {-# LINE 9022 "src/GLuaFixer/AG/ASTLint.hs" #-}+                         )) of+                  { _lhsOmtokenPos ->+                  (case (({-# LINE 535 "src/GLuaFixer/AG/ASTLint.ag" #-}+                          Nothing+                          {-# LINE 9027 "src/GLuaFixer/AG/ASTLint.hs" #-}+                          )) of+                   { _lhsOvarName ->+                   (case ((let sem_PrefixExp_ExprVar_1 :: T_PrefixExp_1+                               sem_PrefixExp_ExprVar_1 =+                                   (\ _lhsIconfig+                                      _lhsIfuncName+                                      _lhsIglobalDefinitions+                                      _lhsIinParentheses+                                      _lhsIisInModule+                                      _lhsIisMeta+                                      _lhsIisNegation+                                      _lhsIloopLevel+                                      _lhsImtokenPos+                                      _lhsIregisterVarUse+                                      _lhsIscopeLevel+                                      _lhsIscopes+                                      _lhsItopLevel+                                      _lhsIvarBeingDefined+                                      _lhsIvariableStyle ->+                                        (case (({-# LINE 178 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIvarBeingDefined+                                                {-# LINE 9049 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _exprOvarBeingDefined ->+                                         (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIscopes+                                                 {-# LINE 9054 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _exprOscopes ->+                                          (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIisMeta+                                                  {-# LINE 9059 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _exprOisMeta ->+                                           (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIconfig+                                                   {-# LINE 9064 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _exprOconfig ->+                                            (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIvariableStyle+                                                    {-# LINE 9069 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _exprOvariableStyle ->+                                             (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIscopeLevel+                                                     {-# LINE 9074 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _exprOscopeLevel ->+                                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsImtokenPos+                                                      {-# LINE 9079 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _exprOmtokenPos ->+                                               (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIloopLevel+                                                       {-# LINE 9084 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _exprOloopLevel ->+                                                (case (({-# LINE 169 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIisNegation+                                                        {-# LINE 9089 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _exprOisNegation ->+                                                 (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsIisInModule+                                                         {-# LINE 9094 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _exprOisInModule ->+                                                  (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIglobalDefinitions+                                                          {-# LINE 9099 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _exprOglobalDefinitions ->+                                                   (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _lhsIfuncName+                                                           {-# LINE 9104 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _exprOfuncName ->+                                                    (case (({-# LINE 538 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            True+                                                            {-# LINE 9109 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _exprOtopLevel ->+                                                     (case (({-# LINE 537 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             True+                                                             {-# LINE 9114 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _exprOinParentheses ->+                                                      (case (expr_1 _exprOconfig _exprOfuncName _exprOglobalDefinitions _exprOinParentheses _exprOisInModule _exprOisMeta _exprOisNegation _exprOloopLevel _exprOmtokenPos _exprOscopeLevel _exprOscopes _exprOtopLevel _exprOvarBeingDefined _exprOvariableStyle) of+                                                       { ( _exprIglobalDefinitions,_exprIidentifier,_exprIisInModule,_exprIisSimpleExpression,_exprIisSingleVar,_exprIscopes,_exprIvariableStyle,_exprIwarnings) ->+                                                           (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _exprIscopes+                                                                   {-# LINE 9121 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _suffixesOscopes ->+                                                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIisMeta+                                                                    {-# LINE 9126 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _suffixesOisMeta ->+                                                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _exprIisInModule+                                                                     {-# LINE 9131 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _suffixesOisInModule ->+                                                              (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _exprIglobalDefinitions+                                                                      {-# LINE 9136 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _suffixesOglobalDefinitions ->+                                                               (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIconfig+                                                                       {-# LINE 9141 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _suffixesOconfig ->+                                                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _exprIvariableStyle+                                                                        {-# LINE 9146 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _suffixesOvariableStyle ->+                                                                 (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _lhsIscopeLevel+                                                                         {-# LINE 9151 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _suffixesOscopeLevel ->+                                                                  (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _exprImtokenPos+                                                                          {-# LINE 9156 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _suffixesOmtokenPos ->+                                                                   (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           _lhsIloopLevel+                                                                           {-# LINE 9161 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _suffixesOloopLevel ->+                                                                    (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            _lhsIfuncName+                                                                            {-# LINE 9166 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _suffixesOfuncName ->+                                                                     (case (suffixes_1 _suffixesOconfig _suffixesOfuncName _suffixesOglobalDefinitions _suffixesOisInModule _suffixesOisMeta _suffixesOloopLevel _suffixesOmtokenPos _suffixesOscopeLevel _suffixesOscopes _suffixesOvariableStyle) of+                                                                      { ( _suffixesIglobalDefinitions,_suffixesIidentifier,_suffixesIisInModule,_suffixesIisSimpleExpression,_suffixesImtokenPos,_suffixesIscopes,_suffixesIvariableStyle,_suffixesIwarnings) ->+                                                                          (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _suffixesIglobalDefinitions+                                                                                  {-# LINE 9173 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOglobalDefinitions ->+                                                                           (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   (const _exprIidentifier _suffixesIidentifier)+                                                                                   {-# LINE 9178 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOidentifier ->+                                                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _suffixesIisInModule+                                                                                    {-# LINE 9183 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOisInModule ->+                                                                             (case (({-# LINE 186 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _exprIisSimpleExpression && _suffixesIisSimpleExpression+                                                                                     {-# LINE 9188 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOisSimpleExpression ->+                                                                              (case (({-# LINE 534 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      Nothing+                                                                                      {-# LINE 9193 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOisSingleVar ->+                                                                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _suffixesIscopes+                                                                                       {-# LINE 9198 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _lhsOscopes ->+                                                                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        _suffixesIvariableStyle+                                                                                        {-# LINE 9203 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _lhsOvariableStyle ->+                                                                                 (case (({-# LINE 539 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         _exprIwarnings ++ _suffixesIwarnings+                                                                                         {-# LINE 9208 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _warnings_augmented_syn ->+                                                                                  (case (({-# LINE 539 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                          if lint_redundantParentheses _lhsIconfig && null _suffixesIcopy && (_lhsIinParentheses || (not _lhsItopLevel && _exprIisSimpleExpression))+                                                                                          then (:) $ warn _lhsImtokenPos UnnecessaryParentheses+                                                                                          else id+                                                                                          {-# LINE 9215 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                          )) of+                                                                                   { _warnings_augmented_f1 ->+                                                                                   (case (({-# LINE 539 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                           foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                                           {-# LINE 9220 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                           )) of+                                                                                    { _lhsOwarnings ->+                                                                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisSimpleExpression,_lhsOisSingleVar,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                           in  sem_PrefixExp_ExprVar_1)) of+                    { ( sem_PrefixExp_1) ->+                    ( _lhsOcopy,_lhsOhasSuffixes,_lhsOmtokenPos,_lhsOvarName,sem_PrefixExp_1) }) }) }) }) }) }) }) })+-- Region ------------------------------------------------------+-- cata+sem_Region :: Region ->+              T_Region+sem_Region (Region _start _end) =+    (sem_Region_Region _start _end)+-- semantic domain+type T_Region = ( Region,String,([String -> LintMessage]))+data Inh_Region = Inh_Region {}+data Syn_Region = Syn_Region {copy_Syn_Region :: Region,identifier_Syn_Region :: String,warnings_Syn_Region :: ([String -> LintMessage])}+wrap_Region :: T_Region ->+               Inh_Region ->+               Syn_Region+wrap_Region sem (Inh_Region) =+    (let ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) = sem+     in  (Syn_Region _lhsOcopy _lhsOidentifier _lhsOwarnings))+sem_Region_Region :: LineColPos ->+                     LineColPos ->+                     T_Region+sem_Region_Region start_ end_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Region start_ end_+            {-# LINE 9249 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 9254 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 9259 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 9264 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+-- Stat --------------------------------------------------------+-- cata+sem_Stat :: Stat ->+            T_Stat+sem_Stat (Def _vars) =+    (sem_Stat_Def (sem_VarsList _vars))+sem_Stat (LocDef _vars) =+    (sem_Stat_LocDef (sem_VarsList _vars))+sem_Stat (AFuncCall _fn) =+    (sem_Stat_AFuncCall (sem_PrefixExp _fn))+sem_Stat (ALabel _lbl) =+    (sem_Stat_ALabel (sem_MToken _lbl))+sem_Stat (ABreak) =+    (sem_Stat_ABreak)+sem_Stat (AContinue) =+    (sem_Stat_AContinue)+sem_Stat (AGoto _lbl) =+    (sem_Stat_AGoto (sem_MToken _lbl))+sem_Stat (ADo _body) =+    (sem_Stat_ADo (sem_Block _body))+sem_Stat (AWhile _cond _body) =+    (sem_Stat_AWhile (sem_MExpr _cond) (sem_Block _body))+sem_Stat (ARepeat _body _cond) =+    (sem_Stat_ARepeat (sem_Block _body) (sem_MExpr _cond))+sem_Stat (AIf _cond _body _elifs _els) =+    (sem_Stat_AIf (sem_MExpr _cond) (sem_Block _body) (sem_ElseIfList _elifs) (sem_Else _els))+sem_Stat (ANFor _var _val _to _step _body) =+    (sem_Stat_ANFor (sem_MToken _var) (sem_MExpr _val) (sem_MExpr _to) (sem_MExpr _step) (sem_Block _body))+sem_Stat (AGFor _vars _vals _body) =+    (sem_Stat_AGFor _vars (sem_MExprList _vals) (sem_Block _body))+sem_Stat (AFunc _name _args _body) =+    (sem_Stat_AFunc (sem_FuncName _name) _args (sem_Block _body))+sem_Stat (ALocFunc _name _args _body) =+    (sem_Stat_ALocFunc (sem_FuncName _name) _args (sem_Block _body))+-- semantic domain+type T_Stat = ( Stat,T_Stat_1)+type T_Stat_1 = LintSettings ->+                String ->+                (M.Map String [Region]) ->+                Bool ->+                Bool ->+                Int ->+                Region ->+                Int ->+                ([M.Map String (Bool, Region)]) ->+                DeterminedVariableStyle ->+                ( (M.Map String [Region]),String,Bool,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_Stat = Inh_Stat {config_Inh_Stat :: LintSettings,funcName_Inh_Stat :: String,globalDefinitions_Inh_Stat :: (M.Map String [Region]),isInModule_Inh_Stat :: Bool,isMeta_Inh_Stat :: Bool,loopLevel_Inh_Stat :: Int,mtokenPos_Inh_Stat :: Region,scopeLevel_Inh_Stat :: Int,scopes_Inh_Stat :: ([M.Map String (Bool, Region)]),variableStyle_Inh_Stat :: DeterminedVariableStyle}+data Syn_Stat = Syn_Stat {copy_Syn_Stat :: Stat,globalDefinitions_Syn_Stat :: (M.Map String [Region]),identifier_Syn_Stat :: String,isIfStatement_Syn_Stat :: Bool,isInModule_Syn_Stat :: Bool,mtokenPos_Syn_Stat :: Region,scopes_Syn_Stat :: ([M.Map String (Bool, Region)]),variableStyle_Syn_Stat :: DeterminedVariableStyle,warnings_Syn_Stat :: ([String -> LintMessage])}+wrap_Stat :: T_Stat ->+             Inh_Stat ->+             Syn_Stat+wrap_Stat sem (Inh_Stat _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_Stat _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisIfStatement _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_Stat_Def :: T_VarsList ->+                T_Stat+sem_Stat_Def vars_ =+    (case (vars_) of+     { ( _varsIcopy,vars_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 Def _varsIcopy+                 {-# LINE 9331 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 9336 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Stat_Def_1 :: T_Stat_1+                       sem_Stat_Def_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 9353 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _varsOscopes ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 9358 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _varsOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 9363 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _varsOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 9368 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _varsOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 9373 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _varsOconfig ->+                                     (case (({-# LINE 314 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             False+                                             {-# LINE 9378 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _varsOlocalDefinition ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 9383 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _varsOvariableStyle ->+                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopeLevel+                                               {-# LINE 9388 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _varsOscopeLevel ->+                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsImtokenPos+                                                {-# LINE 9393 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _varsOmtokenPos ->+                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIloopLevel+                                                 {-# LINE 9398 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _varsOloopLevel ->+                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIfuncName+                                                  {-# LINE 9403 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _varsOfuncName ->+                                           (case (vars_1 _varsOconfig _varsOfuncName _varsOglobalDefinitions _varsOisInModule _varsOisMeta _varsOlocalDefinition _varsOloopLevel _varsOmtokenPos _varsOscopeLevel _varsOscopes _varsOvariableStyle) of+                                            { ( _varsIglobalDefinitions,_varsIidentifier,_varsIisInModule,_varsImtokenPos,_varsIscopes,_varsIvariableStyle,_varsIwarnings) ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _varsIglobalDefinitions+                                                        {-# LINE 9410 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOglobalDefinitions ->+                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _varsIidentifier+                                                         {-# LINE 9415 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOidentifier ->+                                                  (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          False+                                                          {-# LINE 9420 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOisIfStatement ->+                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _varsIisInModule+                                                           {-# LINE 9425 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOisInModule ->+                                                    (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _varsImtokenPos+                                                            {-# LINE 9430 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOmtokenPos ->+                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _varsIscopes+                                                             {-# LINE 9435 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOscopes ->+                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _varsIvariableStyle+                                                              {-# LINE 9440 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOvariableStyle ->+                                                       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _varsIwarnings+                                                               {-# LINE 9445 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOwarnings ->+                                                        ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Stat_Def_1)) of+            { ( sem_Stat_1) ->+            ( _lhsOcopy,sem_Stat_1) }) }) }) })+sem_Stat_LocDef :: T_VarsList ->+                   T_Stat+sem_Stat_LocDef vars_ =+    (case (vars_) of+     { ( _varsIcopy,vars_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 LocDef _varsIcopy+                 {-# LINE 9459 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 9464 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Stat_LocDef_1 :: T_Stat_1+                       sem_Stat_LocDef_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 9481 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _varsOscopes ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 9486 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _varsOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 9491 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _varsOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 9496 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _varsOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 9501 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _varsOconfig ->+                                     (case (({-# LINE 317 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             True+                                             {-# LINE 9506 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _varsOlocalDefinition ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 9511 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _varsOvariableStyle ->+                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopeLevel+                                               {-# LINE 9516 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _varsOscopeLevel ->+                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsImtokenPos+                                                {-# LINE 9521 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _varsOmtokenPos ->+                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIloopLevel+                                                 {-# LINE 9526 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _varsOloopLevel ->+                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIfuncName+                                                  {-# LINE 9531 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _varsOfuncName ->+                                           (case (vars_1 _varsOconfig _varsOfuncName _varsOglobalDefinitions _varsOisInModule _varsOisMeta _varsOlocalDefinition _varsOloopLevel _varsOmtokenPos _varsOscopeLevel _varsOscopes _varsOvariableStyle) of+                                            { ( _varsIglobalDefinitions,_varsIidentifier,_varsIisInModule,_varsImtokenPos,_varsIscopes,_varsIvariableStyle,_varsIwarnings) ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _varsIglobalDefinitions+                                                        {-# LINE 9538 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOglobalDefinitions ->+                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _varsIidentifier+                                                         {-# LINE 9543 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOidentifier ->+                                                  (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          False+                                                          {-# LINE 9548 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOisIfStatement ->+                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _varsIisInModule+                                                           {-# LINE 9553 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOisInModule ->+                                                    (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _varsImtokenPos+                                                            {-# LINE 9558 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOmtokenPos ->+                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _varsIscopes+                                                             {-# LINE 9563 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOscopes ->+                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _varsIvariableStyle+                                                              {-# LINE 9568 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOvariableStyle ->+                                                       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _varsIwarnings+                                                               {-# LINE 9573 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _lhsOwarnings ->+                                                        ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Stat_LocDef_1)) of+            { ( sem_Stat_1) ->+            ( _lhsOcopy,sem_Stat_1) }) }) }) })+sem_Stat_AFuncCall :: T_PrefixExp ->+                      T_Stat+sem_Stat_AFuncCall fn_ =+    (case (fn_) of+     { ( _fnIcopy,_fnIhasSuffixes,_fnImtokenPos,_fnIvarName,fn_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 AFuncCall _fnIcopy+                 {-# LINE 9587 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 9592 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Stat_AFuncCall_1 :: T_Stat_1+                       sem_Stat_AFuncCall_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 9609 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _fnOscopes ->+                                 (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisMeta+                                         {-# LINE 9614 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _fnOisMeta ->+                                  (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIisInModule+                                          {-# LINE 9619 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _fnOisInModule ->+                                   (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIglobalDefinitions+                                           {-# LINE 9624 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _fnOglobalDefinitions ->+                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIconfig+                                            {-# LINE 9629 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _fnOconfig ->+                                     (case (({-# LINE 323 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             Nothing+                                             {-# LINE 9634 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _fnOvarBeingDefined ->+                                      (case (({-# LINE 320 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              True+                                              {-# LINE 9639 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _fnOregisterVarUse ->+                                       (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIvariableStyle+                                               {-# LINE 9644 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _fnOvariableStyle ->+                                        (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIscopeLevel+                                                {-# LINE 9649 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _fnOscopeLevel ->+                                         (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsImtokenPos+                                                 {-# LINE 9654 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _fnOmtokenPos ->+                                          (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIloopLevel+                                                  {-# LINE 9659 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _fnOloopLevel ->+                                           (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIfuncName+                                                   {-# LINE 9664 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _fnOfuncName ->+                                            (case (({-# LINE 322 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    True+                                                    {-# LINE 9669 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _fnOtopLevel ->+                                             (case (({-# LINE 321 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     False+                                                     {-# LINE 9674 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _fnOinParentheses ->+                                              (case (({-# LINE 319 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      False+                                                      {-# LINE 9679 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _fnOisNegation ->+                                               (case (fn_1 _fnOconfig _fnOfuncName _fnOglobalDefinitions _fnOinParentheses _fnOisInModule _fnOisMeta _fnOisNegation _fnOloopLevel _fnOmtokenPos _fnOregisterVarUse _fnOscopeLevel _fnOscopes _fnOtopLevel _fnOvarBeingDefined _fnOvariableStyle) of+                                                { ( _fnIglobalDefinitions,_fnIidentifier,_fnIisInModule,_fnIisSimpleExpression,_fnIisSingleVar,_fnIscopes,_fnIvariableStyle,_fnIwarnings) ->+                                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _fnIglobalDefinitions+                                                            {-# LINE 9686 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOglobalDefinitions ->+                                                     (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _fnIidentifier+                                                             {-# LINE 9691 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOidentifier ->+                                                      (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              False+                                                              {-# LINE 9696 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOisIfStatement ->+                                                       (case (({-# LINE 324 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               (tokenLabel <$> _fnIvarName) == Just "module"+                                                               {-# LINE 9701 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _isModuleCall ->+                                                        (case (({-# LINE 325 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _lhsIisInModule || _isModuleCall+                                                                {-# LINE 9706 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _lhsOisInModule ->+                                                         (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _fnImtokenPos+                                                                 {-# LINE 9711 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOmtokenPos ->+                                                          (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _fnIscopes+                                                                  {-# LINE 9716 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _lhsOscopes ->+                                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _fnIvariableStyle+                                                                   {-# LINE 9721 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _lhsOvariableStyle ->+                                                            (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _fnIwarnings+                                                                    {-# LINE 9726 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _lhsOwarnings ->+                                                             ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Stat_AFuncCall_1)) of+            { ( sem_Stat_1) ->+            ( _lhsOcopy,sem_Stat_1) }) }) }) })+sem_Stat_ALabel :: T_MToken ->+                   T_Stat+sem_Stat_ALabel lbl_ =+    (case (lbl_) of+     { ( _lblIcopy,_lblImtok,_lblImtokenPos,lbl_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 ALabel _lblIcopy+                 {-# LINE 9740 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 9745 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Stat_ALabel_1 :: T_Stat_1+                       sem_Stat_ALabel_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIglobalDefinitions+                                        {-# LINE 9762 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lblOglobalDefinitions ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 9767 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lblOscopes ->+                                  (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsImtokenPos+                                          {-# LINE 9772 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lblOmtokenPos ->+                                   (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIisMeta+                                           {-# LINE 9777 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lblOisMeta ->+                                    (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIisInModule+                                            {-# LINE 9782 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _lblOisInModule ->+                                     (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIfuncName+                                             {-# LINE 9787 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _lblOfuncName ->+                                      (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIconfig+                                              {-# LINE 9792 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _lblOconfig ->+                                       (case (lbl_1 _lblOconfig _lblOfuncName _lblOglobalDefinitions _lblOisInModule _lblOisMeta _lblOmtokenPos _lblOscopes) of+                                        { ( _lblIglobalDefinitions,_lblIidentifier,_lblIisInModule,_lblIscopes,_lblIwarnings) ->+                                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lblIglobalDefinitions+                                                    {-# LINE 9799 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _lhsOglobalDefinitions ->+                                             (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lblIidentifier+                                                     {-# LINE 9804 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _lhsOidentifier ->+                                              (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      False+                                                      {-# LINE 9809 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _lhsOisIfStatement ->+                                               (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lblIisInModule+                                                       {-# LINE 9814 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _lhsOisInModule ->+                                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lblImtokenPos+                                                        {-# LINE 9819 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOmtokenPos ->+                                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lblIscopes+                                                         {-# LINE 9824 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOscopes ->+                                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIvariableStyle+                                                          {-# LINE 9829 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOvariableStyle ->+                                                   (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _lblIwarnings+                                                           {-# LINE 9834 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOwarnings ->+                                                    ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Stat_ALabel_1)) of+            { ( sem_Stat_1) ->+            ( _lhsOcopy,sem_Stat_1) }) }) }) })+sem_Stat_ABreak :: T_Stat+sem_Stat_ABreak =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ABreak+            {-# LINE 9845 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 9850 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_Stat_ABreak_1 :: T_Stat_1+                  sem_Stat_ABreak_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 9867 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 9872 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     False+                                     {-# LINE 9877 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisIfStatement ->+                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsIisInModule+                                      {-# LINE 9882 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisInModule ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 9887 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 9892 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 9897 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 9902 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_Stat_ABreak_1)) of+       { ( sem_Stat_1) ->+       ( _lhsOcopy,sem_Stat_1) }) }) })+sem_Stat_AContinue :: T_Stat+sem_Stat_AContinue =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AContinue+            {-# LINE 9913 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 9918 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_Stat_AContinue_1 :: T_Stat_1+                  sem_Stat_AContinue_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 9935 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 9940 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     False+                                     {-# LINE 9945 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisIfStatement ->+                              (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsIisInModule+                                      {-# LINE 9950 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisInModule ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 9955 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 9960 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 9965 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 9970 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_Stat_AContinue_1)) of+       { ( sem_Stat_1) ->+       ( _lhsOcopy,sem_Stat_1) }) }) })+sem_Stat_AGoto :: T_MToken ->+                  T_Stat+sem_Stat_AGoto lbl_ =+    (case (lbl_) of+     { ( _lblIcopy,_lblImtok,_lblImtokenPos,lbl_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 AGoto _lblIcopy+                 {-# LINE 9984 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 9989 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Stat_AGoto_1 :: T_Stat_1+                       sem_Stat_AGoto_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIglobalDefinitions+                                        {-# LINE 10006 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lblOglobalDefinitions ->+                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIscopes+                                         {-# LINE 10011 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lblOscopes ->+                                  (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsImtokenPos+                                          {-# LINE 10016 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lblOmtokenPos ->+                                   (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIisMeta+                                           {-# LINE 10021 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _lblOisMeta ->+                                    (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            _lhsIisInModule+                                            {-# LINE 10026 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _lblOisInModule ->+                                     (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIfuncName+                                             {-# LINE 10031 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _lblOfuncName ->+                                      (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIconfig+                                              {-# LINE 10036 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _lblOconfig ->+                                       (case (lbl_1 _lblOconfig _lblOfuncName _lblOglobalDefinitions _lblOisInModule _lblOisMeta _lblOmtokenPos _lblOscopes) of+                                        { ( _lblIglobalDefinitions,_lblIidentifier,_lblIisInModule,_lblIscopes,_lblIwarnings) ->+                                            (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lblIglobalDefinitions+                                                    {-# LINE 10043 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _lhsOglobalDefinitions ->+                                             (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lblIidentifier+                                                     {-# LINE 10048 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _lhsOidentifier ->+                                              (case (({-# LINE 208 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      False+                                                      {-# LINE 10053 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _lhsOisIfStatement ->+                                               (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lblIisInModule+                                                       {-# LINE 10058 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _lhsOisInModule ->+                                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lblImtokenPos+                                                        {-# LINE 10063 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOmtokenPos ->+                                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lblIscopes+                                                         {-# LINE 10068 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOscopes ->+                                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIvariableStyle+                                                          {-# LINE 10073 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOvariableStyle ->+                                                   (case (({-# LINE 330 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _lblIwarnings+                                                           {-# LINE 10078 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _warnings_augmented_syn ->+                                                    (case (({-# LINE 330 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            if not (lint_gotos _lhsIconfig) || _lhsIloopLevel >= 2 then id else+                                                              (:) $ warn _lblImtokenPos AvoidGoto+                                                            {-# LINE 10084 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _warnings_augmented_f1 ->+                                                     (case (({-# LINE 330 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                             {-# LINE 10089 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOwarnings ->+                                                      ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Stat_AGoto_1)) of+            { ( sem_Stat_1) ->+            ( _lhsOcopy,sem_Stat_1) }) }) }) })+sem_Stat_ADo :: T_Block ->+                T_Stat+sem_Stat_ADo body_ =+    (case (body_) of+     { ( _bodyIcopy,body_1) ->+         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                 ADo _bodyIcopy+                 {-# LINE 10103 "src/GLuaFixer/AG/ASTLint.hs" #-}+                 )) of+          { _copy ->+          (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                  _copy+                  {-# LINE 10108 "src/GLuaFixer/AG/ASTLint.hs" #-}+                  )) of+           { _lhsOcopy ->+           (case ((let sem_Stat_ADo_1 :: T_Stat_1+                       sem_Stat_ADo_1 =+                           (\ _lhsIconfig+                              _lhsIfuncName+                              _lhsIglobalDefinitions+                              _lhsIisInModule+                              _lhsIisMeta+                              _lhsIloopLevel+                              _lhsImtokenPos+                              _lhsIscopeLevel+                              _lhsIscopes+                              _lhsIvariableStyle ->+                                (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIisMeta+                                        {-# LINE 10125 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _bodyOisMeta ->+                                 (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIisInModule+                                         {-# LINE 10130 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _bodyOisInModule ->+                                  (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          _lhsIglobalDefinitions+                                          {-# LINE 10135 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _bodyOglobalDefinitions ->+                                   (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                           _lhsIconfig+                                           {-# LINE 10140 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                           )) of+                                    { _bodyOconfig ->+                                    (case (({-# LINE 334 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                            M.empty : _lhsIscopes+                                            {-# LINE 10145 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                            )) of+                                     { _bodyOscopes ->+                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIvariableStyle+                                             {-# LINE 10150 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _bodyOvariableStyle ->+                                      (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIscopeLevel+                                              {-# LINE 10155 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _bodyOscopeLevel ->+                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsImtokenPos+                                               {-# LINE 10160 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _bodyOmtokenPos ->+                                        (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIloopLevel+                                                {-# LINE 10165 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _bodyOloopLevel ->+                                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIfuncName+                                                 {-# LINE 10170 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _bodyOfuncName ->+                                          (case (({-# LINE 335 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  False+                                                  {-# LINE 10175 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _bodyOisRepeat ->+                                           (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                            { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _bodyIglobalDefinitions+                                                        {-# LINE 10182 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _lhsOglobalDefinitions ->+                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _bodyIidentifier+                                                         {-# LINE 10187 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _lhsOidentifier ->+                                                  (case (({-# LINE 333 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          False+                                                          {-# LINE 10192 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _lhsOisIfStatement ->+                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _bodyIisInModule+                                                           {-# LINE 10197 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _lhsOisInModule ->+                                                    (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _bodyImtokenPos+                                                            {-# LINE 10202 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _lhsOmtokenPos ->+                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _bodyIscopes+                                                             {-# LINE 10207 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _lhsOscopes ->+                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _bodyIvariableStyle+                                                              {-# LINE 10212 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _lhsOvariableStyle ->+                                                       (case (({-# LINE 336 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _bodyIwarnings+                                                               {-# LINE 10217 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _warnings_augmented_syn ->+                                                        (case (({-# LINE 336 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                if not (lint_emptyBlocks _lhsIconfig) || _bodyIstatementCount > 0 then id else+                                                                  (:) $ warn _lhsImtokenPos EmptyDoBlock+                                                                {-# LINE 10223 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _warnings_augmented_f1 ->+                                                         (case (({-# LINE 336 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                 {-# LINE 10228 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _lhsOwarnings ->+                                                          ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                   in  sem_Stat_ADo_1)) of+            { ( sem_Stat_1) ->+            ( _lhsOcopy,sem_Stat_1) }) }) }) })+sem_Stat_AWhile :: T_MExpr ->+                   T_Block ->+                   T_Stat+sem_Stat_AWhile cond_ body_ =+    (case (body_) of+     { ( _bodyIcopy,body_1) ->+         (case (cond_) of+          { ( _condIcopy,_condImtokenPos,cond_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      AWhile _condIcopy _bodyIcopy+                      {-# LINE 10245 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 10250 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Stat_AWhile_1 :: T_Stat_1+                            sem_Stat_AWhile_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIisMeta+                                             {-# LINE 10267 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _bodyOisMeta ->+                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisInModule+                                              {-# LINE 10272 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _condOisInModule ->+                                       (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIvariableStyle+                                               {-# LINE 10277 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _condOvariableStyle ->+                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIscopes+                                                {-# LINE 10282 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _condOscopes ->+                                         (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIscopeLevel+                                                 {-# LINE 10287 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _condOscopeLevel ->+                                          (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsImtokenPos+                                                  {-# LINE 10292 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _condOmtokenPos ->+                                           (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIloopLevel+                                                   {-# LINE 10297 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _condOloopLevel ->+                                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisMeta+                                                    {-# LINE 10302 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _condOisMeta ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 10307 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _condOglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 10312 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _condOfuncName ->+                                               (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIconfig+                                                       {-# LINE 10317 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _condOconfig ->+                                                (case (({-# LINE 344 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        Nothing+                                                        {-# LINE 10322 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _condOvarBeingDefined ->+                                                 (case (({-# LINE 343 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         True+                                                         {-# LINE 10327 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _condOtopLevel ->+                                                  (case (({-# LINE 342 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          False+                                                          {-# LINE 10332 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _condOinParentheses ->+                                                   (case (({-# LINE 341 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           False+                                                           {-# LINE 10337 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _condOisNegation ->+                                                    (case (cond_1 _condOconfig _condOfuncName _condOglobalDefinitions _condOinParentheses _condOisInModule _condOisMeta _condOisNegation _condOloopLevel _condOmtokenPos _condOscopeLevel _condOscopes _condOtopLevel _condOvarBeingDefined _condOvariableStyle) of+                                                     { ( _condIglobalDefinitions,_condIidentifier,_condIisInModule,_condIisSimpleExpression,_condIisSingleVar,_condIscopes,_condIvariableStyle,_condIwarnings) ->+                                                         (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _condIisInModule+                                                                 {-# LINE 10344 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _bodyOisInModule ->+                                                          (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _condIglobalDefinitions+                                                                  {-# LINE 10349 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _bodyOglobalDefinitions ->+                                                           (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIconfig+                                                                   {-# LINE 10354 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _bodyOconfig ->+                                                            (case (({-# LINE 346 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    M.empty : _condIscopes+                                                                    {-# LINE 10359 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _bodyOscopes ->+                                                             (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _condIvariableStyle+                                                                     {-# LINE 10364 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _bodyOvariableStyle ->+                                                              (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIscopeLevel+                                                                      {-# LINE 10369 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _bodyOscopeLevel ->+                                                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _condImtokenPos+                                                                       {-# LINE 10374 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _bodyOmtokenPos ->+                                                                (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _lhsIfuncName+                                                                        {-# LINE 10379 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _bodyOfuncName ->+                                                                 (case (({-# LINE 345 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         False+                                                                         {-# LINE 10384 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _bodyOisRepeat ->+                                                                  (case (({-# LINE 340 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _lhsIloopLevel + 1+                                                                          {-# LINE 10389 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _bodyOloopLevel ->+                                                                   (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                                                    { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _bodyIglobalDefinitions+                                                                                {-# LINE 10396 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOglobalDefinitions ->+                                                                         (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 (const _condIidentifier _bodyIidentifier)+                                                                                 {-# LINE 10401 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOidentifier ->+                                                                          (case (({-# LINE 339 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  False+                                                                                  {-# LINE 10406 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOisIfStatement ->+                                                                           (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _bodyIisInModule+                                                                                   {-# LINE 10411 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOisInModule ->+                                                                            (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _bodyImtokenPos+                                                                                    {-# LINE 10416 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOmtokenPos ->+                                                                             (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _bodyIscopes+                                                                                     {-# LINE 10421 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOscopes ->+                                                                              (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _bodyIvariableStyle+                                                                                      {-# LINE 10426 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOvariableStyle ->+                                                                               (case (({-# LINE 347 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _condIwarnings ++ _bodyIwarnings+                                                                                       {-# LINE 10431 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _warnings_augmented_syn ->+                                                                                (case (({-# LINE 347 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        if not (lint_emptyBlocks _lhsIconfig) || _bodyIstatementCount > 0 then id else+                                                                                          (:) $ warn _lhsImtokenPos EmptyWhileLoop+                                                                                        {-# LINE 10437 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _warnings_augmented_f1 ->+                                                                                 (case (({-# LINE 347 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                                         {-# LINE 10442 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _lhsOwarnings ->+                                                                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Stat_AWhile_1)) of+                 { ( sem_Stat_1) ->+                 ( _lhsOcopy,sem_Stat_1) }) }) }) }) })+sem_Stat_ARepeat :: T_Block ->+                    T_MExpr ->+                    T_Stat+sem_Stat_ARepeat body_ cond_ =+    (case (cond_) of+     { ( _condIcopy,_condImtokenPos,cond_1) ->+         (case (body_) of+          { ( _bodyIcopy,body_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      ARepeat _bodyIcopy _condIcopy+                      {-# LINE 10459 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 10464 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Stat_ARepeat_1 :: T_Stat_1+                            sem_Stat_ARepeat_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIisMeta+                                             {-# LINE 10481 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _bodyOisMeta ->+                                      (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIconfig+                                              {-# LINE 10486 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _bodyOconfig ->+                                       (case (({-# LINE 358 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               M.empty : _lhsIscopes+                                               {-# LINE 10491 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _bodyOscopes ->+                                        (case (({-# LINE 357 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                True+                                                {-# LINE 10496 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _bodyOisRepeat ->+                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIvariableStyle+                                                 {-# LINE 10501 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _bodyOvariableStyle ->+                                          (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIscopeLevel+                                                  {-# LINE 10506 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _bodyOscopeLevel ->+                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsImtokenPos+                                                   {-# LINE 10511 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _bodyOmtokenPos ->+                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisInModule+                                                    {-# LINE 10516 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _bodyOisInModule ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 10521 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _bodyOglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 10526 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _bodyOfuncName ->+                                               (case (({-# LINE 352 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIloopLevel + 1+                                                       {-# LINE 10531 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _bodyOloopLevel ->+                                                (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                                 { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _bodyIscopes+                                                             {-# LINE 10538 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _condOscopes ->+                                                      (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _lhsIisMeta+                                                              {-# LINE 10543 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _condOisMeta ->+                                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _bodyIisInModule+                                                               {-# LINE 10548 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _condOisInModule ->+                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _bodyIglobalDefinitions+                                                                {-# LINE 10553 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _condOglobalDefinitions ->+                                                         (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _lhsIconfig+                                                                 {-# LINE 10558 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _condOconfig ->+                                                          (case (({-# LINE 356 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  Nothing+                                                                  {-# LINE 10563 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _condOvarBeingDefined ->+                                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _bodyIvariableStyle+                                                                   {-# LINE 10568 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _condOvariableStyle ->+                                                            (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIscopeLevel+                                                                    {-# LINE 10573 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _condOscopeLevel ->+                                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _bodyImtokenPos+                                                                     {-# LINE 10578 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _condOmtokenPos ->+                                                              (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIloopLevel+                                                                      {-# LINE 10583 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _condOloopLevel ->+                                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIfuncName+                                                                       {-# LINE 10588 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _condOfuncName ->+                                                                (case (({-# LINE 355 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        True+                                                                        {-# LINE 10593 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _condOtopLevel ->+                                                                 (case (({-# LINE 354 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         False+                                                                         {-# LINE 10598 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _condOinParentheses ->+                                                                  (case (({-# LINE 353 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          False+                                                                          {-# LINE 10603 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _condOisNegation ->+                                                                   (case (cond_1 _condOconfig _condOfuncName _condOglobalDefinitions _condOinParentheses _condOisInModule _condOisMeta _condOisNegation _condOloopLevel _condOmtokenPos _condOscopeLevel _condOscopes _condOtopLevel _condOvarBeingDefined _condOvariableStyle) of+                                                                    { ( _condIglobalDefinitions,_condIidentifier,_condIisInModule,_condIisSimpleExpression,_condIisSingleVar,_condIscopes,_condIvariableStyle,_condIwarnings) ->+                                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _condIglobalDefinitions+                                                                                {-# LINE 10610 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOglobalDefinitions ->+                                                                         (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 (const _bodyIidentifier _condIidentifier)+                                                                                 {-# LINE 10615 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOidentifier ->+                                                                          (case (({-# LINE 351 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  False+                                                                                  {-# LINE 10620 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOisIfStatement ->+                                                                           (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _condIisInModule+                                                                                   {-# LINE 10625 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOisInModule ->+                                                                            (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _condImtokenPos+                                                                                    {-# LINE 10630 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOmtokenPos ->+                                                                             (case (({-# LINE 359 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     tail _condIscopes+                                                                                     {-# LINE 10635 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOscopes ->+                                                                              (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _condIvariableStyle+                                                                                      {-# LINE 10640 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOvariableStyle ->+                                                                               (case (({-# LINE 360 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _bodyIwarnings ++ _condIwarnings+                                                                                       {-# LINE 10645 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _warnings_augmented_syn ->+                                                                                (case (({-# LINE 360 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        if not (lint_emptyBlocks _lhsIconfig) || _bodyIstatementCount > 0 then id else+                                                                                          (:) $ warn _lhsImtokenPos EmptyRepeat+                                                                                        {-# LINE 10651 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _warnings_augmented_f1 ->+                                                                                 (case (({-# LINE 360 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                                         {-# LINE 10656 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _lhsOwarnings ->+                                                                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Stat_ARepeat_1)) of+                 { ( sem_Stat_1) ->+                 ( _lhsOcopy,sem_Stat_1) }) }) }) }) })+sem_Stat_AIf :: T_MExpr ->+                T_Block ->+                T_ElseIfList ->+                T_Else ->+                T_Stat+sem_Stat_AIf cond_ body_ elifs_ els_ =+    (case (els_) of+     { ( _elsIcopy,els_1) ->+         (case (elifs_) of+          { ( _elifsIcopy,elifs_1) ->+              (case (body_) of+               { ( _bodyIcopy,body_1) ->+                   (case (cond_) of+                    { ( _condIcopy,_condImtokenPos,cond_1) ->+                        (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                AIf _condIcopy _bodyIcopy _elifsIcopy _elsIcopy+                                {-# LINE 10679 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                )) of+                         { _copy ->+                         (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                 _copy+                                 {-# LINE 10684 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                 )) of+                          { _lhsOcopy ->+                          (case ((let sem_Stat_AIf_1 :: T_Stat_1+                                      sem_Stat_AIf_1 =+                                          (\ _lhsIconfig+                                             _lhsIfuncName+                                             _lhsIglobalDefinitions+                                             _lhsIisInModule+                                             _lhsIisMeta+                                             _lhsIloopLevel+                                             _lhsImtokenPos+                                             _lhsIscopeLevel+                                             _lhsIscopes+                                             _lhsIvariableStyle ->+                                               (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIisMeta+                                                       {-# LINE 10701 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _bodyOisMeta ->+                                                (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        _lhsIconfig+                                                        {-# LINE 10706 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _bodyOconfig ->+                                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         _lhsIscopes+                                                         {-# LINE 10711 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _condOscopes ->+                                                  (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                          _lhsIisMeta+                                                          {-# LINE 10716 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                          )) of+                                                   { _condOisMeta ->+                                                   (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                           _lhsIconfig+                                                           {-# LINE 10721 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                           )) of+                                                    { _condOconfig ->+                                                    (case (({-# LINE 373 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            False+                                                            {-# LINE 10726 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _bodyOisRepeat ->+                                                     (case (({-# LINE 371 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             Nothing+                                                             {-# LINE 10731 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _condOvarBeingDefined ->+                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _lhsIvariableStyle+                                                              {-# LINE 10736 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _condOvariableStyle ->+                                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _lhsIscopeLevel+                                                               {-# LINE 10741 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _condOscopeLevel ->+                                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _lhsImtokenPos+                                                                {-# LINE 10746 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _condOmtokenPos ->+                                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _lhsIloopLevel+                                                                 {-# LINE 10751 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _condOloopLevel ->+                                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIisInModule+                                                                  {-# LINE 10756 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _condOisInModule ->+                                                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIglobalDefinitions+                                                                   {-# LINE 10761 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _condOglobalDefinitions ->+                                                            (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIfuncName+                                                                    {-# LINE 10766 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _condOfuncName ->+                                                             (case (({-# LINE 370 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     True+                                                                     {-# LINE 10771 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _condOtopLevel ->+                                                              (case (({-# LINE 369 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      False+                                                                      {-# LINE 10776 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _condOinParentheses ->+                                                               (case (({-# LINE 368 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       False+                                                                       {-# LINE 10781 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _condOisNegation ->+                                                                (case (cond_1 _condOconfig _condOfuncName _condOglobalDefinitions _condOinParentheses _condOisInModule _condOisMeta _condOisNegation _condOloopLevel _condOmtokenPos _condOscopeLevel _condOscopes _condOtopLevel _condOvarBeingDefined _condOvariableStyle) of+                                                                 { ( _condIglobalDefinitions,_condIidentifier,_condIisInModule,_condIisSimpleExpression,_condIisSingleVar,_condIscopes,_condIvariableStyle,_condIwarnings) ->+                                                                     (case (({-# LINE 372 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             M.empty : _condIscopes+                                                                             {-# LINE 10788 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _bodyOscopes ->+                                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _condIvariableStyle+                                                                              {-# LINE 10793 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _bodyOvariableStyle ->+                                                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _lhsIscopeLevel+                                                                               {-# LINE 10798 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _bodyOscopeLevel ->+                                                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _condImtokenPos+                                                                                {-# LINE 10803 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _bodyOmtokenPos ->+                                                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _lhsIloopLevel+                                                                                 {-# LINE 10808 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _bodyOloopLevel ->+                                                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _condIisInModule+                                                                                  {-# LINE 10813 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _bodyOisInModule ->+                                                                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _condIglobalDefinitions+                                                                                   {-# LINE 10818 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _bodyOglobalDefinitions ->+                                                                            (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _lhsIfuncName+                                                                                    {-# LINE 10823 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _bodyOfuncName ->+                                                                             (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                                                              { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                                                  (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                          _bodyIscopes+                                                                                          {-# LINE 10830 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                          )) of+                                                                                   { _elifsOscopes ->+                                                                                   (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                           _lhsIisMeta+                                                                                           {-# LINE 10835 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                           )) of+                                                                                    { _elifsOisMeta ->+                                                                                    (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                            _lhsIconfig+                                                                                            {-# LINE 10840 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                            )) of+                                                                                     { _elifsOconfig ->+                                                                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                             _bodyIvariableStyle+                                                                                             {-# LINE 10845 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                             )) of+                                                                                      { _elifsOvariableStyle ->+                                                                                      (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                              _lhsIscopeLevel+                                                                                              {-# LINE 10850 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                              )) of+                                                                                       { _elifsOscopeLevel ->+                                                                                       (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                               _lhsIloopLevel+                                                                                               {-# LINE 10855 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                               )) of+                                                                                        { _elifsOloopLevel ->+                                                                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                _bodyIisInModule+                                                                                                {-# LINE 10860 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                )) of+                                                                                         { _elifsOisInModule ->+                                                                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                 _bodyIglobalDefinitions+                                                                                                 {-# LINE 10865 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                 )) of+                                                                                          { _elifsOglobalDefinitions ->+                                                                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                  _lhsIfuncName+                                                                                                  {-# LINE 10870 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                  )) of+                                                                                           { _elifsOfuncName ->+                                                                                           (case (({-# LINE 374 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                   _lhsImtokenPos+                                                                                                   {-# LINE 10875 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                   )) of+                                                                                            { _elifsOmtokenPos ->+                                                                                            (case (elifs_1 _elifsOconfig _elifsOfuncName _elifsOglobalDefinitions _elifsOisInModule _elifsOisMeta _elifsOloopLevel _elifsOmtokenPos _elifsOscopeLevel _elifsOscopes _elifsOvariableStyle) of+                                                                                             { ( _elifsIelseExists,_elifsIglobalDefinitions,_elifsIidentifier,_elifsIisInModule,_elifsImtokenPos,_elifsIscopes,_elifsIvariableStyle,_elifsIwarnings) ->+                                                                                                 (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                         _elifsIscopes+                                                                                                         {-# LINE 10882 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                         )) of+                                                                                                  { _elsOscopes ->+                                                                                                  (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                          _lhsIisMeta+                                                                                                          {-# LINE 10887 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                          )) of+                                                                                                   { _elsOisMeta ->+                                                                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                           _elifsIisInModule+                                                                                                           {-# LINE 10892 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                           )) of+                                                                                                    { _elsOisInModule ->+                                                                                                    (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                            _elifsIglobalDefinitions+                                                                                                            {-# LINE 10897 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                            )) of+                                                                                                     { _elsOglobalDefinitions ->+                                                                                                     (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                             _lhsIconfig+                                                                                                             {-# LINE 10902 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                             )) of+                                                                                                      { _elsOconfig ->+                                                                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                              _elifsIvariableStyle+                                                                                                              {-# LINE 10907 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                              )) of+                                                                                                       { _elsOvariableStyle ->+                                                                                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                               _lhsIscopeLevel+                                                                                                               {-# LINE 10912 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                               )) of+                                                                                                        { _elsOscopeLevel ->+                                                                                                        (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                _lhsIloopLevel+                                                                                                                {-# LINE 10917 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                )) of+                                                                                                         { _elsOloopLevel ->+                                                                                                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                 _lhsIfuncName+                                                                                                                 {-# LINE 10922 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                 )) of+                                                                                                          { _elsOfuncName ->+                                                                                                          (case (({-# LINE 375 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                  _lhsImtokenPos+                                                                                                                  {-# LINE 10927 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                  )) of+                                                                                                           { _elsOmtokenPos ->+                                                                                                           (case (els_1 _elsOconfig _elsOfuncName _elsOglobalDefinitions _elsOisInModule _elsOisMeta _elsOloopLevel _elsOmtokenPos _elsOscopeLevel _elsOscopes _elsOvariableStyle) of+                                                                                                            { ( _elsIelseExists,_elsIglobalDefinitions,_elsIidentifier,_elsIisInModule,_elsImtokenPos,_elsIscopes,_elsIvariableStyle,_elsIwarnings) ->+                                                                                                                (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                        _elsIglobalDefinitions+                                                                                                                        {-# LINE 10934 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                        )) of+                                                                                                                 { _lhsOglobalDefinitions ->+                                                                                                                 (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                         (const _condIidentifier (const _bodyIidentifier (const _elifsIidentifier _elsIidentifier)))+                                                                                                                         {-# LINE 10939 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                         )) of+                                                                                                                  { _lhsOidentifier ->+                                                                                                                  (case (({-# LINE 367 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                          not _elifsIelseExists && not _elsIelseExists+                                                                                                                          {-# LINE 10944 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                          )) of+                                                                                                                   { _lhsOisIfStatement ->+                                                                                                                   (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                           _elsIisInModule+                                                                                                                           {-# LINE 10949 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                           )) of+                                                                                                                    { _lhsOisInModule ->+                                                                                                                    (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                            _elsImtokenPos+                                                                                                                            {-# LINE 10954 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                            )) of+                                                                                                                     { _lhsOmtokenPos ->+                                                                                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                             _elsIscopes+                                                                                                                             {-# LINE 10959 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                             )) of+                                                                                                                      { _lhsOscopes ->+                                                                                                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                              _elsIvariableStyle+                                                                                                                              {-# LINE 10964 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                              )) of+                                                                                                                       { _lhsOvariableStyle ->+                                                                                                                       (case (({-# LINE 383 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                               _condIwarnings ++ _bodyIwarnings ++ _elifsIwarnings ++ _elsIwarnings+                                                                                                                               {-# LINE 10969 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                               )) of+                                                                                                                        { _warnings_augmented_syn ->+                                                                                                                        (case (({-# LINE 376 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                Region (rgStart _lhsImtokenPos) (customAdvanceToken (rgStart _lhsImtokenPos) If)+                                                                                                                                {-# LINE 10974 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                )) of+                                                                                                                         { _keywordPos ->+                                                                                                                         (case (({-# LINE 383 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                 if not (lint_emptyBlocks _lhsIconfig) || _bodyIstatementCount > 0 then id else+                                                                                                                                   (:) $ warn _keywordPos     EmptyIf+                                                                                                                                 {-# LINE 10980 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                 )) of+                                                                                                                          { _warnings_augmented_f2 ->+                                                                                                                          (case (({-# LINE 383 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                  if not (lint_redundantIfStatements _lhsIconfig) || _bodyIstatementCount /= 1 || not _bodyIisIfStatement || _elifsIelseExists || _elsIelseExists then id else+                                                                                                                                    (:) $ warn _bodyImtokenPos DoubleIf+                                                                                                                                  {-# LINE 10986 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                  )) of+                                                                                                                           { _warnings_augmented_f1 ->+                                                                                                                           (case (({-# LINE 383 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                   foldr ($) _warnings_augmented_syn [_warnings_augmented_f1, _warnings_augmented_f2]+                                                                                                                                   {-# LINE 10991 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                   )) of+                                                                                                                            { _lhsOwarnings ->+                                                                                                                            ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                                  in  sem_Stat_AIf_1)) of+                           { ( sem_Stat_1) ->+                           ( _lhsOcopy,sem_Stat_1) }) }) }) }) }) }) })+sem_Stat_ANFor :: T_MToken ->+                  T_MExpr ->+                  T_MExpr ->+                  T_MExpr ->+                  T_Block ->+                  T_Stat+sem_Stat_ANFor var_ val_ to_ step_ body_ =+    (case (body_) of+     { ( _bodyIcopy,body_1) ->+         (case (step_) of+          { ( _stepIcopy,_stepImtokenPos,step_1) ->+              (case (to_) of+               { ( _toIcopy,_toImtokenPos,to_1) ->+                   (case (val_) of+                    { ( _valIcopy,_valImtokenPos,val_1) ->+                        (case (var_) of+                         { ( _varIcopy,_varImtok,_varImtokenPos,var_1) ->+                             (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     ANFor _varIcopy _valIcopy _toIcopy _stepIcopy _bodyIcopy+                                     {-# LINE 11017 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _copy ->+                              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _copy+                                      {-# LINE 11022 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOcopy ->+                               (case ((let sem_Stat_ANFor_1 :: T_Stat_1+                                           sem_Stat_ANFor_1 =+                                               (\ _lhsIconfig+                                                  _lhsIfuncName+                                                  _lhsIglobalDefinitions+                                                  _lhsIisInModule+                                                  _lhsIisMeta+                                                  _lhsIloopLevel+                                                  _lhsImtokenPos+                                                  _lhsIscopeLevel+                                                  _lhsIscopes+                                                  _lhsIvariableStyle ->+                                                    (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                            _lhsIisMeta+                                                            {-# LINE 11039 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                            )) of+                                                     { _bodyOisMeta ->+                                                     (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _lhsIisInModule+                                                             {-# LINE 11044 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _varOisInModule ->+                                                      (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _lhsIscopes+                                                              {-# LINE 11049 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _varOscopes ->+                                                       (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _lhsImtokenPos+                                                               {-# LINE 11054 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _varOmtokenPos ->+                                                        (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _lhsIisMeta+                                                                {-# LINE 11059 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _varOisMeta ->+                                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _lhsIglobalDefinitions+                                                                 {-# LINE 11064 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _varOglobalDefinitions ->+                                                          (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIfuncName+                                                                  {-# LINE 11069 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _varOfuncName ->+                                                           (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _lhsIconfig+                                                                   {-# LINE 11074 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _varOconfig ->+                                                            (case (var_1 _varOconfig _varOfuncName _varOglobalDefinitions _varOisInModule _varOisMeta _varOmtokenPos _varOscopes) of+                                                             { ( _varIglobalDefinitions,_varIidentifier,_varIisInModule,_varIscopes,_varIwarnings) ->+                                                                 (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _varIisInModule+                                                                         {-# LINE 11081 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _valOisInModule ->+                                                                  (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          _lhsIvariableStyle+                                                                          {-# LINE 11086 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _valOvariableStyle ->+                                                                   (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                           _varIscopes+                                                                           {-# LINE 11091 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                           )) of+                                                                    { _valOscopes ->+                                                                    (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                            _lhsIscopeLevel+                                                                            {-# LINE 11096 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                            )) of+                                                                     { _valOscopeLevel ->+                                                                     (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _varImtokenPos+                                                                             {-# LINE 11101 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _valOmtokenPos ->+                                                                      (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              _lhsIloopLevel+                                                                              {-# LINE 11106 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _valOloopLevel ->+                                                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _lhsIisMeta+                                                                               {-# LINE 11111 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _valOisMeta ->+                                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _varIglobalDefinitions+                                                                                {-# LINE 11116 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _valOglobalDefinitions ->+                                                                         (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _lhsIfuncName+                                                                                 {-# LINE 11121 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _valOfuncName ->+                                                                          (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _lhsIconfig+                                                                                  {-# LINE 11126 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _valOconfig ->+                                                                           (case (({-# LINE 391 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   Nothing+                                                                                   {-# LINE 11131 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _valOvarBeingDefined ->+                                                                            (case (({-# LINE 390 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    True+                                                                                    {-# LINE 11136 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _valOtopLevel ->+                                                                             (case (({-# LINE 389 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     False+                                                                                     {-# LINE 11141 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _valOinParentheses ->+                                                                              (case (({-# LINE 388 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      False+                                                                                      {-# LINE 11146 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _valOisNegation ->+                                                                               (case (val_1 _valOconfig _valOfuncName _valOglobalDefinitions _valOinParentheses _valOisInModule _valOisMeta _valOisNegation _valOloopLevel _valOmtokenPos _valOscopeLevel _valOscopes _valOtopLevel _valOvarBeingDefined _valOvariableStyle) of+                                                                                { ( _valIglobalDefinitions,_valIidentifier,_valIisInModule,_valIisSimpleExpression,_valIisSingleVar,_valIscopes,_valIvariableStyle,_valIwarnings) ->+                                                                                    (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                            _valIisInModule+                                                                                            {-# LINE 11153 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                            )) of+                                                                                     { _toOisInModule ->+                                                                                     (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                             _valIvariableStyle+                                                                                             {-# LINE 11158 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                             )) of+                                                                                      { _toOvariableStyle ->+                                                                                      (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                              _valIscopes+                                                                                              {-# LINE 11163 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                              )) of+                                                                                       { _toOscopes ->+                                                                                       (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                               _lhsIscopeLevel+                                                                                               {-# LINE 11168 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                               )) of+                                                                                        { _toOscopeLevel ->+                                                                                        (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                _valImtokenPos+                                                                                                {-# LINE 11173 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                )) of+                                                                                         { _toOmtokenPos ->+                                                                                         (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                 _lhsIloopLevel+                                                                                                 {-# LINE 11178 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                 )) of+                                                                                          { _toOloopLevel ->+                                                                                          (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                  _lhsIisMeta+                                                                                                  {-# LINE 11183 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                  )) of+                                                                                           { _toOisMeta ->+                                                                                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                   _valIglobalDefinitions+                                                                                                   {-# LINE 11188 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                   )) of+                                                                                            { _toOglobalDefinitions ->+                                                                                            (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                    _lhsIfuncName+                                                                                                    {-# LINE 11193 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                    )) of+                                                                                             { _toOfuncName ->+                                                                                             (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                     _lhsIconfig+                                                                                                     {-# LINE 11198 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                     )) of+                                                                                              { _toOconfig ->+                                                                                              (case (({-# LINE 395 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                      Nothing+                                                                                                      {-# LINE 11203 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                      )) of+                                                                                               { _toOvarBeingDefined ->+                                                                                               (case (({-# LINE 394 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                       True+                                                                                                       {-# LINE 11208 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                       )) of+                                                                                                { _toOtopLevel ->+                                                                                                (case (({-# LINE 393 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                        False+                                                                                                        {-# LINE 11213 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                        )) of+                                                                                                 { _toOinParentheses ->+                                                                                                 (case (({-# LINE 392 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                         False+                                                                                                         {-# LINE 11218 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                         )) of+                                                                                                  { _toOisNegation ->+                                                                                                  (case (to_1 _toOconfig _toOfuncName _toOglobalDefinitions _toOinParentheses _toOisInModule _toOisMeta _toOisNegation _toOloopLevel _toOmtokenPos _toOscopeLevel _toOscopes _toOtopLevel _toOvarBeingDefined _toOvariableStyle) of+                                                                                                   { ( _toIglobalDefinitions,_toIidentifier,_toIisInModule,_toIisSimpleExpression,_toIisSingleVar,_toIscopes,_toIvariableStyle,_toIwarnings) ->+                                                                                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                               _toIisInModule+                                                                                                               {-# LINE 11225 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                               )) of+                                                                                                        { _stepOisInModule ->+                                                                                                        (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                _toIvariableStyle+                                                                                                                {-# LINE 11230 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                )) of+                                                                                                         { _stepOvariableStyle ->+                                                                                                         (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                 _toIscopes+                                                                                                                 {-# LINE 11235 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                 )) of+                                                                                                          { _stepOscopes ->+                                                                                                          (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                  _lhsIscopeLevel+                                                                                                                  {-# LINE 11240 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                  )) of+                                                                                                           { _stepOscopeLevel ->+                                                                                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                   _toImtokenPos+                                                                                                                   {-# LINE 11245 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                   )) of+                                                                                                            { _stepOmtokenPos ->+                                                                                                            (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                    _lhsIloopLevel+                                                                                                                    {-# LINE 11250 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                    )) of+                                                                                                             { _stepOloopLevel ->+                                                                                                             (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                     _lhsIisMeta+                                                                                                                     {-# LINE 11255 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                     )) of+                                                                                                              { _stepOisMeta ->+                                                                                                              (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                      _toIglobalDefinitions+                                                                                                                      {-# LINE 11260 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                      )) of+                                                                                                               { _stepOglobalDefinitions ->+                                                                                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                       _lhsIfuncName+                                                                                                                       {-# LINE 11265 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                       )) of+                                                                                                                { _stepOfuncName ->+                                                                                                                (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                        _lhsIconfig+                                                                                                                        {-# LINE 11270 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                        )) of+                                                                                                                 { _stepOconfig ->+                                                                                                                 (case (({-# LINE 400 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                         Nothing+                                                                                                                         {-# LINE 11275 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                         )) of+                                                                                                                  { _stepOvarBeingDefined ->+                                                                                                                  (case (({-# LINE 399 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                          True+                                                                                                                          {-# LINE 11280 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                          )) of+                                                                                                                   { _stepOtopLevel ->+                                                                                                                   (case (({-# LINE 398 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                           False+                                                                                                                           {-# LINE 11285 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                           )) of+                                                                                                                    { _stepOinParentheses ->+                                                                                                                    (case (({-# LINE 397 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                            False+                                                                                                                            {-# LINE 11290 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                            )) of+                                                                                                                     { _stepOisNegation ->+                                                                                                                     (case (step_1 _stepOconfig _stepOfuncName _stepOglobalDefinitions _stepOinParentheses _stepOisInModule _stepOisMeta _stepOisNegation _stepOloopLevel _stepOmtokenPos _stepOscopeLevel _stepOscopes _stepOtopLevel _stepOvarBeingDefined _stepOvariableStyle) of+                                                                                                                      { ( _stepIglobalDefinitions,_stepIidentifier,_stepIisInModule,_stepIisSimpleExpression,_stepIisSingleVar,_stepIscopes,_stepIvariableStyle,_stepIwarnings) ->+                                                                                                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                  _stepIisInModule+                                                                                                                                  {-# LINE 11297 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                  )) of+                                                                                                                           { _bodyOisInModule ->+                                                                                                                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                   _stepIglobalDefinitions+                                                                                                                                   {-# LINE 11302 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                   )) of+                                                                                                                            { _bodyOglobalDefinitions ->+                                                                                                                            (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                    _lhsIconfig+                                                                                                                                    {-# LINE 11307 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                    )) of+                                                                                                                             { _bodyOconfig ->+                                                                                                                             (case (({-# LINE 401 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                     M.singleton _varIidentifier (not (lint_unusedLoopVars _lhsIconfig), _varImtokenPos) : _stepIscopes+                                                                                                                                     {-# LINE 11312 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                     )) of+                                                                                                                              { _bodyOscopes ->+                                                                                                                              (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                      _stepIvariableStyle+                                                                                                                                      {-# LINE 11317 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                      )) of+                                                                                                                               { _bodyOvariableStyle ->+                                                                                                                               (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                       _lhsIscopeLevel+                                                                                                                                       {-# LINE 11322 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                       )) of+                                                                                                                                { _bodyOscopeLevel ->+                                                                                                                                (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                        _stepImtokenPos+                                                                                                                                        {-# LINE 11327 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                        )) of+                                                                                                                                 { _bodyOmtokenPos ->+                                                                                                                                 (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                         _lhsIfuncName+                                                                                                                                         {-# LINE 11332 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                         )) of+                                                                                                                                  { _bodyOfuncName ->+                                                                                                                                  (case (({-# LINE 396 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                          False+                                                                                                                                          {-# LINE 11337 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                          )) of+                                                                                                                                   { _bodyOisRepeat ->+                                                                                                                                   (case (({-# LINE 387 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                           _lhsIloopLevel + 1+                                                                                                                                           {-# LINE 11342 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                           )) of+                                                                                                                                    { _bodyOloopLevel ->+                                                                                                                                    (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                                                                                                                     { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                                                                                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                 _bodyIglobalDefinitions+                                                                                                                                                 {-# LINE 11349 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                 )) of+                                                                                                                                          { _lhsOglobalDefinitions ->+                                                                                                                                          (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                  (const _varIidentifier (const _valIidentifier (const _toIidentifier (const _stepIidentifier _bodyIidentifier))))+                                                                                                                                                  {-# LINE 11354 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                  )) of+                                                                                                                                           { _lhsOidentifier ->+                                                                                                                                           (case (({-# LINE 386 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                   False+                                                                                                                                                   {-# LINE 11359 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                   )) of+                                                                                                                                            { _lhsOisIfStatement ->+                                                                                                                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                    _bodyIisInModule+                                                                                                                                                    {-# LINE 11364 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                    )) of+                                                                                                                                             { _lhsOisInModule ->+                                                                                                                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                     _bodyImtokenPos+                                                                                                                                                     {-# LINE 11369 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                     )) of+                                                                                                                                              { _lhsOmtokenPos ->+                                                                                                                                              (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                      _bodyIscopes+                                                                                                                                                      {-# LINE 11374 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                      )) of+                                                                                                                                               { _lhsOscopes ->+                                                                                                                                               (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                       _bodyIvariableStyle+                                                                                                                                                       {-# LINE 11379 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                       )) of+                                                                                                                                                { _lhsOvariableStyle ->+                                                                                                                                                (case (({-# LINE 405 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                        _varIwarnings ++ _valIwarnings ++ _toIwarnings ++ _stepIwarnings ++ _bodyIwarnings+                                                                                                                                                        {-# LINE 11384 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                        )) of+                                                                                                                                                 { _warnings_augmented_syn ->+                                                                                                                                                 (case (({-# LINE 402 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                         checkShadows _lhsIscopes _varIcopy+                                                                                                                                                         {-# LINE 11389 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                         )) of+                                                                                                                                                  { _shadowWarning ->+                                                                                                                                                  (case (({-# LINE 405 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                          if not (lint_shadowing _lhsIconfig) || isNothing _shadowWarning     then id else+                                                                                                                                                            (:) . fromMaybe (error "fromMaybe ANFor +warnings") $ _shadowWarning+                                                                                                                                                          {-# LINE 11395 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                          )) of+                                                                                                                                                   { _warnings_augmented_f2 ->+                                                                                                                                                   (case (({-# LINE 405 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                           if not (lint_emptyBlocks _lhsIconfig) || _bodyIstatementCount > 0 then id else+                                                                                                                                                             (:) $ warn _lhsImtokenPos EmptyFor+                                                                                                                                                           {-# LINE 11401 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                           )) of+                                                                                                                                                    { _warnings_augmented_f1 ->+                                                                                                                                                    (case (({-# LINE 405 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                                                                                            foldr ($) _warnings_augmented_syn [_warnings_augmented_f1, _warnings_augmented_f2]+                                                                                                                                                            {-# LINE 11406 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                                                                                            )) of+                                                                                                                                                     { _lhsOwarnings ->+                                                                                                                                                     ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                                       in  sem_Stat_ANFor_1)) of+                                { ( sem_Stat_1) ->+                                ( _lhsOcopy,sem_Stat_1) }) }) }) }) }) }) }) })+sem_Stat_AGFor :: ([MToken]) ->+                  T_MExprList ->+                  T_Block ->+                  T_Stat+sem_Stat_AGFor vars_ vals_ body_ =+    (case (body_) of+     { ( _bodyIcopy,body_1) ->+         (case (vals_) of+          { ( _valsIcopy,vals_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      AGFor vars_ _valsIcopy _bodyIcopy+                      {-# LINE 11424 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 11429 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Stat_AGFor_1 :: T_Stat_1+                            sem_Stat_AGFor_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIisMeta+                                             {-# LINE 11446 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _bodyOisMeta ->+                                      (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIisInModule+                                              {-# LINE 11451 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _valsOisInModule ->+                                       (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIvariableStyle+                                               {-# LINE 11456 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _valsOvariableStyle ->+                                        (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIscopes+                                                {-# LINE 11461 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _valsOscopes ->+                                         (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIscopeLevel+                                                 {-# LINE 11466 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _valsOscopeLevel ->+                                          (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsImtokenPos+                                                  {-# LINE 11471 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _valsOmtokenPos ->+                                           (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsIloopLevel+                                                   {-# LINE 11476 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _valsOloopLevel ->+                                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIisMeta+                                                    {-# LINE 11481 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _valsOisMeta ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 11486 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _valsOglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 11491 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _valsOfuncName ->+                                               (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIconfig+                                                       {-# LINE 11496 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _valsOconfig ->+                                                (case (({-# LINE 410 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                        True+                                                        {-# LINE 11501 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                        )) of+                                                 { _valsOtopLevel ->+                                                 (case (({-# LINE 409 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                         True+                                                         {-# LINE 11506 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                         )) of+                                                  { _valsOinParentheses ->+                                                  (case (vals_1 _valsOconfig _valsOfuncName _valsOglobalDefinitions _valsOinParentheses _valsOisInModule _valsOisMeta _valsOloopLevel _valsOmtokenPos _valsOscopeLevel _valsOscopes _valsOtopLevel _valsOvariableStyle) of+                                                   { ( _valsIglobalDefinitions,_valsIidentifier,_valsIisInModule,_valsImtokenPos,_valsIscopes,_valsIvariableStyle,_valsIwarnings) ->+                                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _valsIisInModule+                                                               {-# LINE 11513 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _bodyOisInModule ->+                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _valsIglobalDefinitions+                                                                {-# LINE 11518 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _bodyOglobalDefinitions ->+                                                         (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _lhsIconfig+                                                                 {-# LINE 11523 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _bodyOconfig ->+                                                          (case (({-# LINE 414 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  M.fromList $ map (\mt -> (tokenLabel mt, (not (lint_unusedLoopVars _lhsIconfig), mpos mt))) vars_+                                                                  {-# LINE 11528 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _introduces ->+                                                           (case (({-# LINE 415 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _introduces     : _valsIscopes+                                                                   {-# LINE 11533 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _bodyOscopes ->+                                                            (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _valsIvariableStyle+                                                                    {-# LINE 11538 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _bodyOvariableStyle ->+                                                             (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _lhsIscopeLevel+                                                                     {-# LINE 11543 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _bodyOscopeLevel ->+                                                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _valsImtokenPos+                                                                      {-# LINE 11548 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _bodyOmtokenPos ->+                                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIfuncName+                                                                       {-# LINE 11553 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _bodyOfuncName ->+                                                                (case (({-# LINE 412 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        False+                                                                        {-# LINE 11558 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _bodyOisRepeat ->+                                                                 (case (({-# LINE 411 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _lhsIloopLevel + 1+                                                                         {-# LINE 11563 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _bodyOloopLevel ->+                                                                  (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                                                   { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                                       (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _bodyIglobalDefinitions+                                                                               {-# LINE 11570 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOglobalDefinitions ->+                                                                        (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                (const _valsIidentifier _bodyIidentifier)+                                                                                {-# LINE 11575 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOidentifier ->+                                                                         (case (({-# LINE 408 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 False+                                                                                 {-# LINE 11580 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOisIfStatement ->+                                                                          (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _bodyIisInModule+                                                                                  {-# LINE 11585 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOisInModule ->+                                                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _bodyImtokenPos+                                                                                   {-# LINE 11590 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOmtokenPos ->+                                                                            (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _bodyIscopes+                                                                                    {-# LINE 11595 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOscopes ->+                                                                             (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _bodyIvariableStyle+                                                                                     {-# LINE 11600 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOvariableStyle ->+                                                                              (case (({-# LINE 418 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _valsIwarnings ++ _bodyIwarnings+                                                                                      {-# LINE 11605 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _warnings_augmented_syn ->+                                                                               (case (({-# LINE 418 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       if not (lint_shadowing _lhsIconfig) then id else+                                                                                         (++) . catMaybes . map (checkShadows _lhsIscopes) $ vars_+                                                                                       {-# LINE 11611 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _warnings_augmented_f2 ->+                                                                                (case (({-# LINE 418 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        if not (lint_emptyBlocks _lhsIconfig) || _bodyIstatementCount > 0 then id else+                                                                                          (:) $ warn _lhsImtokenPos EmptyFor+                                                                                        {-# LINE 11617 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _warnings_augmented_f1 ->+                                                                                 (case (({-# LINE 418 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         foldr ($) _warnings_augmented_syn [_warnings_augmented_f1, _warnings_augmented_f2]+                                                                                         {-# LINE 11622 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _lhsOwarnings ->+                                                                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Stat_AGFor_1)) of+                 { ( sem_Stat_1) ->+                 ( _lhsOcopy,sem_Stat_1) }) }) }) }) })+sem_Stat_AFunc :: T_FuncName ->+                  ([MToken]) ->+                  T_Block ->+                  T_Stat+sem_Stat_AFunc name_ args_ body_ =+    (case (body_) of+     { ( _bodyIcopy,body_1) ->+         (case (name_) of+          { ( _nameIcopy,_nameIisMeta,name_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      AFunc _nameIcopy args_ _bodyIcopy+                      {-# LINE 11640 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 11645 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Stat_AFunc_1 :: T_Stat_1+                            sem_Stat_AFunc_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIisInModule+                                             {-# LINE 11662 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _nameOisInModule ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 11667 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _nameOvariableStyle ->+                                       (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopes+                                               {-# LINE 11672 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _nameOscopes ->+                                        (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIscopeLevel+                                                {-# LINE 11677 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _nameOscopeLevel ->+                                         (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsImtokenPos+                                                 {-# LINE 11682 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _nameOmtokenPos ->+                                          (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIloopLevel+                                                  {-# LINE 11687 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _nameOloopLevel ->+                                           (case (({-# LINE 433 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _nameIisMeta || findSelf args_ || _lhsIisMeta+                                                   {-# LINE 11692 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _isMeta ->+                                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _isMeta+                                                    {-# LINE 11697 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _nameOisMeta ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 11702 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _nameOglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 11707 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _nameOfuncName ->+                                               (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIconfig+                                                       {-# LINE 11712 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _nameOconfig ->+                                                (case (name_1 _nameOconfig _nameOfuncName _nameOglobalDefinitions _nameOisInModule _nameOisMeta _nameOloopLevel _nameOmtokenPos _nameOscopeLevel _nameOscopes _nameOvariableStyle) of+                                                 { ( _nameIglobalDefinitions,_nameIhasSuffixes,_nameIidentifier,_nameIisInModule,_nameImtokenPos,_nameIscopes,_nameIvariableStyle,_nameIwarnings) ->+                                                     (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _nameIisInModule+                                                             {-# LINE 11719 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _bodyOisInModule ->+                                                      (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _nameIglobalDefinitions+                                                              {-# LINE 11724 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _bodyOglobalDefinitions ->+                                                       (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _lhsIconfig+                                                               {-# LINE 11729 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _bodyOconfig ->+                                                        (case (({-# LINE 434 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _isMeta+                                                                {-# LINE 11734 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _bodyOisMeta ->+                                                         (case (({-# LINE 422 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 filter (/= MToken emptyRg VarArg) $ args_+                                                                 {-# LINE 11739 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _argIdentifiers ->+                                                          (case (({-# LINE 424 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  (if _isMeta     then M.insert "self" (True, _nameImtokenPos) else id) $+                                                                    M.fromList . map (\mt -> (tokenLabel mt, (not . lint_unusedParameters $ _lhsIconfig, mpos mt))) $ _argIdentifiers+                                                                  {-# LINE 11745 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _introduces ->+                                                           (case (({-# LINE 426 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _introduces     : (registerVariable _nameIscopes _nameImtokenPos _nameIidentifier True)+                                                                   {-# LINE 11750 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _bodyOscopes ->+                                                            (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _nameIvariableStyle+                                                                    {-# LINE 11755 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _bodyOvariableStyle ->+                                                             (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _lhsIscopeLevel+                                                                     {-# LINE 11760 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _bodyOscopeLevel ->+                                                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _nameImtokenPos+                                                                      {-# LINE 11765 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _bodyOmtokenPos ->+                                                               (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIloopLevel+                                                                       {-# LINE 11770 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _bodyOloopLevel ->+                                                                (case (({-# LINE 435 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _nameIidentifier+                                                                        {-# LINE 11775 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _bodyOfuncName ->+                                                                 (case (({-# LINE 423 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         False+                                                                         {-# LINE 11780 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _bodyOisRepeat ->+                                                                  (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                                                   { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                                       (case (({-# LINE 428 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _bodyIglobalDefinitions+                                                                               {-# LINE 11787 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _globalDefinitions_augmented_syn ->+                                                                        (case (({-# LINE 428 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                if _lhsIisInModule || isVariableLocal _lhsIscopes _nameIidentifier || _nameIisMeta || _nameIhasSuffixes then id else+                                                                                  M.insertWith (++) _nameIidentifier [_nameImtokenPos]+                                                                                {-# LINE 11793 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _globalDefinitions_augmented_f1 ->+                                                                         (case (({-# LINE 428 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 foldr ($) _globalDefinitions_augmented_syn [_globalDefinitions_augmented_f1]+                                                                                 {-# LINE 11798 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOglobalDefinitions ->+                                                                          (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  (const _nameIidentifier _bodyIidentifier)+                                                                                  {-# LINE 11803 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOidentifier ->+                                                                           (case (({-# LINE 421 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   False+                                                                                   {-# LINE 11808 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOisIfStatement ->+                                                                            (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _bodyIisInModule+                                                                                    {-# LINE 11813 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOisInModule ->+                                                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _bodyImtokenPos+                                                                                     {-# LINE 11818 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOmtokenPos ->+                                                                              (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _bodyIscopes+                                                                                      {-# LINE 11823 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOscopes ->+                                                                               (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _bodyIvariableStyle+                                                                                       {-# LINE 11828 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _lhsOvariableStyle ->+                                                                                (case (({-# LINE 431 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        _nameIwarnings ++ _bodyIwarnings+                                                                                        {-# LINE 11833 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _warnings_augmented_syn ->+                                                                                 (case (({-# LINE 431 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         if not (lint_shadowing _lhsIconfig) then id else+                                                                                           (++) . catMaybes . map (checkShadows _lhsIscopes) $ _argIdentifiers+                                                                                         {-# LINE 11839 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _warnings_augmented_f1 ->+                                                                                  (case (({-# LINE 431 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                          foldr ($) _warnings_augmented_syn [_warnings_augmented_f1]+                                                                                          {-# LINE 11844 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                          )) of+                                                                                   { _lhsOwarnings ->+                                                                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Stat_AFunc_1)) of+                 { ( sem_Stat_1) ->+                 ( _lhsOcopy,sem_Stat_1) }) }) }) }) })+sem_Stat_ALocFunc :: T_FuncName ->+                     ([MToken]) ->+                     T_Block ->+                     T_Stat+sem_Stat_ALocFunc name_ args_ body_ =+    (case (body_) of+     { ( _bodyIcopy,body_1) ->+         (case (name_) of+          { ( _nameIcopy,_nameIisMeta,name_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      ALocFunc _nameIcopy args_ _bodyIcopy+                      {-# LINE 11862 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 11867 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_Stat_ALocFunc_1 :: T_Stat_1+                            sem_Stat_ALocFunc_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIisInModule+                                             {-# LINE 11884 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _nameOisInModule ->+                                      (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIvariableStyle+                                              {-# LINE 11889 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _nameOvariableStyle ->+                                       (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIscopes+                                               {-# LINE 11894 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _nameOscopes ->+                                        (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIscopeLevel+                                                {-# LINE 11899 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _nameOscopeLevel ->+                                         (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsImtokenPos+                                                 {-# LINE 11904 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _nameOmtokenPos ->+                                          (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIloopLevel+                                                  {-# LINE 11909 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _nameOloopLevel ->+                                           (case (({-# LINE 446 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   findSelf args_ || _lhsIisMeta+                                                   {-# LINE 11914 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _isMeta ->+                                            (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _isMeta+                                                    {-# LINE 11919 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _nameOisMeta ->+                                             (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIglobalDefinitions+                                                     {-# LINE 11924 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _nameOglobalDefinitions ->+                                              (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIfuncName+                                                      {-# LINE 11929 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _nameOfuncName ->+                                               (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIconfig+                                                       {-# LINE 11934 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _nameOconfig ->+                                                (case (name_1 _nameOconfig _nameOfuncName _nameOglobalDefinitions _nameOisInModule _nameOisMeta _nameOloopLevel _nameOmtokenPos _nameOscopeLevel _nameOscopes _nameOvariableStyle) of+                                                 { ( _nameIglobalDefinitions,_nameIhasSuffixes,_nameIidentifier,_nameIisInModule,_nameImtokenPos,_nameIscopes,_nameIvariableStyle,_nameIwarnings) ->+                                                     (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _nameIisInModule+                                                             {-# LINE 11941 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _bodyOisInModule ->+                                                      (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _nameIglobalDefinitions+                                                              {-# LINE 11946 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _bodyOglobalDefinitions ->+                                                       (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _lhsIconfig+                                                               {-# LINE 11951 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _bodyOconfig ->+                                                        (case (({-# LINE 447 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _isMeta+                                                                {-# LINE 11956 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _bodyOisMeta ->+                                                         (case (({-# LINE 444 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 M.insert _nameIidentifier (False, _nameImtokenPos) (head _nameIscopes) : tail _nameIscopes+                                                                 {-# LINE 11961 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _passedScopes ->+                                                          (case (({-# LINE 438 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  filter (/= MToken emptyRg VarArg) $ args_+                                                                  {-# LINE 11966 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _argIdentifiers ->+                                                           (case (({-# LINE 440 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   (if _isMeta     then M.insert "self" (True, _nameImtokenPos) else id) $+                                                                     M.fromList . map (\mt -> (tokenLabel mt, (not . lint_unusedParameters $ _lhsIconfig, mpos mt))) $ _argIdentifiers+                                                                   {-# LINE 11972 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _introduces ->+                                                            (case (({-# LINE 445 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _introduces     : _passedScopes+                                                                    {-# LINE 11977 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _bodyOscopes ->+                                                             (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _nameIvariableStyle+                                                                     {-# LINE 11982 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _bodyOvariableStyle ->+                                                              (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIscopeLevel+                                                                      {-# LINE 11987 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _bodyOscopeLevel ->+                                                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _nameImtokenPos+                                                                       {-# LINE 11992 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _bodyOmtokenPos ->+                                                                (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                        _lhsIloopLevel+                                                                        {-# LINE 11997 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                        )) of+                                                                 { _bodyOloopLevel ->+                                                                 (case (({-# LINE 448 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                         _nameIidentifier+                                                                         {-# LINE 12002 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                         )) of+                                                                  { _bodyOfuncName ->+                                                                  (case (({-# LINE 439 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                          False+                                                                          {-# LINE 12007 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                          )) of+                                                                   { _bodyOisRepeat ->+                                                                   (case (body_1 _bodyOconfig _bodyOfuncName _bodyOglobalDefinitions _bodyOisInModule _bodyOisMeta _bodyOisRepeat _bodyOloopLevel _bodyOmtokenPos _bodyOscopeLevel _bodyOscopes _bodyOvariableStyle) of+                                                                    { ( _bodyIglobalDefinitions,_bodyIidentifier,_bodyIisIfStatement,_bodyIisInModule,_bodyImtokenPos,_bodyIscopes,_bodyIstatementCount,_bodyIvariableStyle,_bodyIwarnings) ->+                                                                        (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _bodyIglobalDefinitions+                                                                                {-# LINE 12014 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOglobalDefinitions ->+                                                                         (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 (const _nameIidentifier _bodyIidentifier)+                                                                                 {-# LINE 12019 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOidentifier ->+                                                                          (case (({-# LINE 437 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  False+                                                                                  {-# LINE 12024 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOisIfStatement ->+                                                                           (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _bodyIisInModule+                                                                                   {-# LINE 12029 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOisInModule ->+                                                                            (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                    _bodyImtokenPos+                                                                                    {-# LINE 12034 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                    )) of+                                                                             { _lhsOmtokenPos ->+                                                                             (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                     _bodyIscopes+                                                                                     {-# LINE 12039 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                     )) of+                                                                              { _lhsOscopes ->+                                                                              (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                      _bodyIvariableStyle+                                                                                      {-# LINE 12044 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                      )) of+                                                                               { _lhsOvariableStyle ->+                                                                               (case (({-# LINE 454 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                       _nameIwarnings ++ _bodyIwarnings+                                                                                       {-# LINE 12049 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                       )) of+                                                                                { _warnings_augmented_syn ->+                                                                                (case (({-# LINE 443 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                        MToken _nameImtokenPos (Identifier _nameIidentifier)+                                                                                        {-# LINE 12054 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                        )) of+                                                                                 { _funcname ->+                                                                                 (case (({-# LINE 453 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                         checkShadows _lhsIscopes _funcname+                                                                                         {-# LINE 12059 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                         )) of+                                                                                  { _funcNameShadows ->+                                                                                  (case (({-# LINE 454 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                          if not (lint_shadowing _lhsIconfig) then id else+                                                                                            (++) . catMaybes . map (checkShadows _lhsIscopes) $ _argIdentifiers+                                                                                          {-# LINE 12065 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                          )) of+                                                                                   { _warnings_augmented_f2 ->+                                                                                   (case (({-# LINE 454 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                           if not (lint_shadowing _lhsIconfig) || isNothing _funcNameShadows     then id else+                                                                                             (:) . fromMaybe (error "fromMaybe ALocFunc +warnings") $ _funcNameShadows+                                                                                           {-# LINE 12071 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                           )) of+                                                                                    { _warnings_augmented_f1 ->+                                                                                    (case (({-# LINE 454 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                            foldr ($) _warnings_augmented_syn [_warnings_augmented_f1, _warnings_augmented_f2]+                                                                                            {-# LINE 12076 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                            )) of+                                                                                     { _lhsOwarnings ->+                                                                                     ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisIfStatement,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_Stat_ALocFunc_1)) of+                 { ( sem_Stat_1) ->+                 ( _lhsOcopy,sem_Stat_1) }) }) }) }) })+-- Token -------------------------------------------------------+-- cata+sem_Token :: Token ->+             T_Token+sem_Token (Whitespace _space) =+    (sem_Token_Whitespace _space)+sem_Token (DashComment _comment) =+    (sem_Token_DashComment _comment)+sem_Token (DashBlockComment _depth _comment) =+    (sem_Token_DashBlockComment _depth _comment)+sem_Token (SlashComment _comment) =+    (sem_Token_SlashComment _comment)+sem_Token (SlashBlockComment _comment) =+    (sem_Token_SlashBlockComment _comment)+sem_Token (Semicolon) =+    (sem_Token_Semicolon)+sem_Token (TNumber _num) =+    (sem_Token_TNumber _num)+sem_Token (DQString _str) =+    (sem_Token_DQString _str)+sem_Token (SQString _str) =+    (sem_Token_SQString _str)+sem_Token (MLString _str) =+    (sem_Token_MLString _str)+sem_Token (TTrue) =+    (sem_Token_TTrue)+sem_Token (TFalse) =+    (sem_Token_TFalse)+sem_Token (Nil) =+    (sem_Token_Nil)+sem_Token (VarArg) =+    (sem_Token_VarArg)+sem_Token (Plus) =+    (sem_Token_Plus)+sem_Token (Minus) =+    (sem_Token_Minus)+sem_Token (Multiply) =+    (sem_Token_Multiply)+sem_Token (Divide) =+    (sem_Token_Divide)+sem_Token (Modulus) =+    (sem_Token_Modulus)+sem_Token (Power) =+    (sem_Token_Power)+sem_Token (TEq) =+    (sem_Token_TEq)+sem_Token (TNEq) =+    (sem_Token_TNEq)+sem_Token (TCNEq) =+    (sem_Token_TCNEq)+sem_Token (TLEQ) =+    (sem_Token_TLEQ)+sem_Token (TGEQ) =+    (sem_Token_TGEQ)+sem_Token (TLT) =+    (sem_Token_TLT)+sem_Token (TGT) =+    (sem_Token_TGT)+sem_Token (Equals) =+    (sem_Token_Equals)+sem_Token (Concatenate) =+    (sem_Token_Concatenate)+sem_Token (Colon) =+    (sem_Token_Colon)+sem_Token (Dot) =+    (sem_Token_Dot)+sem_Token (Comma) =+    (sem_Token_Comma)+sem_Token (Hash) =+    (sem_Token_Hash)+sem_Token (Not) =+    (sem_Token_Not)+sem_Token (CNot) =+    (sem_Token_CNot)+sem_Token (And) =+    (sem_Token_And)+sem_Token (CAnd) =+    (sem_Token_CAnd)+sem_Token (Or) =+    (sem_Token_Or)+sem_Token (COr) =+    (sem_Token_COr)+sem_Token (Function) =+    (sem_Token_Function)+sem_Token (Local) =+    (sem_Token_Local)+sem_Token (If) =+    (sem_Token_If)+sem_Token (Then) =+    (sem_Token_Then)+sem_Token (Elseif) =+    (sem_Token_Elseif)+sem_Token (Else) =+    (sem_Token_Else)+sem_Token (For) =+    (sem_Token_For)+sem_Token (In) =+    (sem_Token_In)+sem_Token (Do) =+    (sem_Token_Do)+sem_Token (While) =+    (sem_Token_While)+sem_Token (Until) =+    (sem_Token_Until)+sem_Token (Repeat) =+    (sem_Token_Repeat)+sem_Token (Continue) =+    (sem_Token_Continue)+sem_Token (Break) =+    (sem_Token_Break)+sem_Token (Return) =+    (sem_Token_Return)+sem_Token (End) =+    (sem_Token_End)+sem_Token (LRound) =+    (sem_Token_LRound)+sem_Token (RRound) =+    (sem_Token_RRound)+sem_Token (LCurly) =+    (sem_Token_LCurly)+sem_Token (RCurly) =+    (sem_Token_RCurly)+sem_Token (LSquare) =+    (sem_Token_LSquare)+sem_Token (RSquare) =+    (sem_Token_RSquare)+sem_Token (Label _lbl) =+    (sem_Token_Label _lbl)+sem_Token (Identifier _ident) =+    (sem_Token_Identifier _ident)+-- semantic domain+type T_Token = ( Token,String,([String -> LintMessage]))+data Inh_Token = Inh_Token {}+data Syn_Token = Syn_Token {copy_Syn_Token :: Token,identifier_Syn_Token :: String,warnings_Syn_Token :: ([String -> LintMessage])}+wrap_Token :: T_Token ->+              Inh_Token ->+              Syn_Token+wrap_Token sem (Inh_Token) =+    (let ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) = sem+     in  (Syn_Token _lhsOcopy _lhsOidentifier _lhsOwarnings))+sem_Token_Whitespace :: String ->+                        T_Token+sem_Token_Whitespace space_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Whitespace space_+            {-# LINE 12228 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12233 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12238 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12243 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_DashComment :: String ->+                         T_Token+sem_Token_DashComment comment_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            DashComment comment_+            {-# LINE 12252 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12257 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12262 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12267 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_DashBlockComment :: Int ->+                              String ->+                              T_Token+sem_Token_DashBlockComment depth_ comment_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            DashBlockComment depth_ comment_+            {-# LINE 12277 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12282 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12287 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12292 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_SlashComment :: String ->+                          T_Token+sem_Token_SlashComment comment_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            SlashComment comment_+            {-# LINE 12301 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12306 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12311 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12316 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_SlashBlockComment :: String ->+                               T_Token+sem_Token_SlashBlockComment comment_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            SlashBlockComment comment_+            {-# LINE 12325 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12330 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12335 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12340 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Semicolon :: T_Token+sem_Token_Semicolon =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Semicolon+            {-# LINE 12348 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12353 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12358 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12363 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TNumber :: String ->+                     T_Token+sem_Token_TNumber num_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TNumber num_+            {-# LINE 12372 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12377 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12382 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12387 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_DQString :: String ->+                      T_Token+sem_Token_DQString str_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            DQString str_+            {-# LINE 12396 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12401 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12406 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12411 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_SQString :: String ->+                      T_Token+sem_Token_SQString str_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            SQString str_+            {-# LINE 12420 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12425 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12430 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12435 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_MLString :: String ->+                      T_Token+sem_Token_MLString str_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            MLString str_+            {-# LINE 12444 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12449 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12454 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12459 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TTrue :: T_Token+sem_Token_TTrue =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TTrue+            {-# LINE 12467 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12472 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12477 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12482 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TFalse :: T_Token+sem_Token_TFalse =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TFalse+            {-# LINE 12490 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12495 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12500 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12505 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Nil :: T_Token+sem_Token_Nil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Nil+            {-# LINE 12513 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12518 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12523 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12528 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_VarArg :: T_Token+sem_Token_VarArg =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            VarArg+            {-# LINE 12536 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12541 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12546 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12551 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Plus :: T_Token+sem_Token_Plus =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Plus+            {-# LINE 12559 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12564 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12569 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12574 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Minus :: T_Token+sem_Token_Minus =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Minus+            {-# LINE 12582 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12587 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12592 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12597 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Multiply :: T_Token+sem_Token_Multiply =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Multiply+            {-# LINE 12605 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12610 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12615 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12620 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Divide :: T_Token+sem_Token_Divide =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Divide+            {-# LINE 12628 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12633 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12638 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12643 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Modulus :: T_Token+sem_Token_Modulus =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Modulus+            {-# LINE 12651 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12656 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12661 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12666 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Power :: T_Token+sem_Token_Power =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Power+            {-# LINE 12674 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12679 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12684 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12689 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TEq :: T_Token+sem_Token_TEq =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TEq+            {-# LINE 12697 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12702 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12707 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12712 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TNEq :: T_Token+sem_Token_TNEq =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TNEq+            {-# LINE 12720 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12725 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12730 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12735 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TCNEq :: T_Token+sem_Token_TCNEq =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TCNEq+            {-# LINE 12743 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12748 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12753 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12758 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TLEQ :: T_Token+sem_Token_TLEQ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TLEQ+            {-# LINE 12766 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12771 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12776 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12781 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TGEQ :: T_Token+sem_Token_TGEQ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TGEQ+            {-# LINE 12789 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12794 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12799 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12804 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TLT :: T_Token+sem_Token_TLT =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TLT+            {-# LINE 12812 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12817 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12822 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12827 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_TGT :: T_Token+sem_Token_TGT =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            TGT+            {-# LINE 12835 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12840 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12845 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12850 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Equals :: T_Token+sem_Token_Equals =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Equals+            {-# LINE 12858 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12863 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12868 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12873 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Concatenate :: T_Token+sem_Token_Concatenate =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Concatenate+            {-# LINE 12881 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12886 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12891 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12896 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Colon :: T_Token+sem_Token_Colon =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Colon+            {-# LINE 12904 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12909 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12914 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12919 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Dot :: T_Token+sem_Token_Dot =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Dot+            {-# LINE 12927 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12932 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12937 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12942 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Comma :: T_Token+sem_Token_Comma =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Comma+            {-# LINE 12950 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12955 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12960 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12965 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Hash :: T_Token+sem_Token_Hash =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Hash+            {-# LINE 12973 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 12978 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 12983 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 12988 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Not :: T_Token+sem_Token_Not =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Not+            {-# LINE 12996 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13001 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13006 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13011 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_CNot :: T_Token+sem_Token_CNot =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            CNot+            {-# LINE 13019 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13024 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13029 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13034 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_And :: T_Token+sem_Token_And =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            And+            {-# LINE 13042 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13047 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13052 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13057 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_CAnd :: T_Token+sem_Token_CAnd =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            CAnd+            {-# LINE 13065 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13070 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13075 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13080 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Or :: T_Token+sem_Token_Or =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Or+            {-# LINE 13088 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13093 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13098 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13103 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_COr :: T_Token+sem_Token_COr =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            COr+            {-# LINE 13111 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13116 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13121 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13126 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Function :: T_Token+sem_Token_Function =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Function+            {-# LINE 13134 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13139 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13144 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13149 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Local :: T_Token+sem_Token_Local =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Local+            {-# LINE 13157 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13162 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13167 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13172 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_If :: T_Token+sem_Token_If =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            If+            {-# LINE 13180 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13185 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13190 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13195 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Then :: T_Token+sem_Token_Then =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Then+            {-# LINE 13203 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13208 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13213 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13218 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Elseif :: T_Token+sem_Token_Elseif =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Elseif+            {-# LINE 13226 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13231 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13236 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13241 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Else :: T_Token+sem_Token_Else =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Else+            {-# LINE 13249 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13254 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13259 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13264 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_For :: T_Token+sem_Token_For =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            For+            {-# LINE 13272 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13277 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13282 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13287 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_In :: T_Token+sem_Token_In =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            In+            {-# LINE 13295 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13300 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13305 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13310 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Do :: T_Token+sem_Token_Do =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Do+            {-# LINE 13318 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13323 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13328 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13333 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_While :: T_Token+sem_Token_While =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            While+            {-# LINE 13341 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13346 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13351 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13356 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Until :: T_Token+sem_Token_Until =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Until+            {-# LINE 13364 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13369 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13374 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13379 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Repeat :: T_Token+sem_Token_Repeat =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Repeat+            {-# LINE 13387 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13392 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13397 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13402 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Continue :: T_Token+sem_Token_Continue =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Continue+            {-# LINE 13410 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13415 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13420 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13425 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Break :: T_Token+sem_Token_Break =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Break+            {-# LINE 13433 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13438 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13443 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13448 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Return :: T_Token+sem_Token_Return =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Return+            {-# LINE 13456 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13461 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13466 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13471 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_End :: T_Token+sem_Token_End =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            End+            {-# LINE 13479 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13484 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13489 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13494 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_LRound :: T_Token+sem_Token_LRound =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            LRound+            {-# LINE 13502 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13507 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13512 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13517 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_RRound :: T_Token+sem_Token_RRound =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            RRound+            {-# LINE 13525 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13530 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13535 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13540 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_LCurly :: T_Token+sem_Token_LCurly =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            LCurly+            {-# LINE 13548 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13553 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13558 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13563 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_RCurly :: T_Token+sem_Token_RCurly =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            RCurly+            {-# LINE 13571 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13576 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13581 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13586 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_LSquare :: T_Token+sem_Token_LSquare =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            LSquare+            {-# LINE 13594 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13599 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13604 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13609 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_RSquare :: T_Token+sem_Token_RSquare =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            RSquare+            {-# LINE 13617 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13622 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13627 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13632 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Label :: String ->+                   T_Token+sem_Token_Label lbl_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Label lbl_+            {-# LINE 13641 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13646 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 220 "src/GLuaFixer/AG/ASTLint.ag" #-}+              lbl_+              {-# LINE 13651 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13656 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+sem_Token_Identifier :: String ->+                        T_Token+sem_Token_Identifier ident_ =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            Identifier ident_+            {-# LINE 13665 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13670 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 222 "src/GLuaFixer/AG/ASTLint.ag" #-}+              ident_+              {-# LINE 13675 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13680 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+-- TokenList ---------------------------------------------------+-- cata+sem_TokenList :: TokenList ->+                 T_TokenList+sem_TokenList list =+    (Prelude.foldr sem_TokenList_Cons sem_TokenList_Nil (Prelude.map sem_Token list))+-- semantic domain+type T_TokenList = ( TokenList,String,([String -> LintMessage]))+data Inh_TokenList = Inh_TokenList {}+data Syn_TokenList = Syn_TokenList {copy_Syn_TokenList :: TokenList,identifier_Syn_TokenList :: String,warnings_Syn_TokenList :: ([String -> LintMessage])}+wrap_TokenList :: T_TokenList ->+                  Inh_TokenList ->+                  Syn_TokenList+wrap_TokenList sem (Inh_TokenList) =+    (let ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) = sem+     in  (Syn_TokenList _lhsOcopy _lhsOidentifier _lhsOwarnings))+sem_TokenList_Cons :: T_Token ->+                      T_TokenList ->+                      T_TokenList+sem_TokenList_Cons hd_ tl_ =+    (case (tl_) of+     { ( _tlIcopy,_tlIidentifier,_tlIwarnings) ->+         (case (hd_) of+          { ( _hdIcopy,_hdIidentifier,_hdIwarnings) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (:) _hdIcopy _tlIcopy+                      {-# LINE 13710 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 13715 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                        (const _hdIidentifier _tlIidentifier)+                        {-# LINE 13720 "src/GLuaFixer/AG/ASTLint.hs" #-}+                        )) of+                 { _lhsOidentifier ->+                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                         _hdIwarnings ++ _tlIwarnings+                         {-# LINE 13725 "src/GLuaFixer/AG/ASTLint.hs" #-}+                         )) of+                  { _lhsOwarnings ->+                  ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) }) }) })+sem_TokenList_Nil :: T_TokenList+sem_TokenList_Nil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            []+            {-# LINE 13733 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13738 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+              unknownIdentifier+              {-# LINE 13743 "src/GLuaFixer/AG/ASTLint.hs" #-}+              )) of+       { _lhsOidentifier ->+       (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+               []+               {-# LINE 13748 "src/GLuaFixer/AG/ASTLint.hs" #-}+               )) of+        { _lhsOwarnings ->+        ( _lhsOcopy,_lhsOidentifier,_lhsOwarnings) }) }) }) })+-- UnOp --------------------------------------------------------+-- cata+sem_UnOp :: UnOp ->+            T_UnOp+sem_UnOp (UnMinus) =+    (sem_UnOp_UnMinus)+sem_UnOp (ANot) =+    (sem_UnOp_ANot)+sem_UnOp (AHash) =+    (sem_UnOp_AHash)+-- semantic domain+type T_UnOp = ( UnOp,T_UnOp_1)+type T_UnOp_1 = LintSettings ->+                String ->+                (M.Map String [Region]) ->+                Bool ->+                Bool ->+                Int ->+                Region ->+                Int ->+                ([M.Map String (Bool, Region)]) ->+                DeterminedVariableStyle ->+                ( (M.Map String [Region]),String,Bool,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_UnOp = Inh_UnOp {config_Inh_UnOp :: LintSettings,funcName_Inh_UnOp :: String,globalDefinitions_Inh_UnOp :: (M.Map String [Region]),isInModule_Inh_UnOp :: Bool,isMeta_Inh_UnOp :: Bool,loopLevel_Inh_UnOp :: Int,mtokenPos_Inh_UnOp :: Region,scopeLevel_Inh_UnOp :: Int,scopes_Inh_UnOp :: ([M.Map String (Bool, Region)]),variableStyle_Inh_UnOp :: DeterminedVariableStyle}+data Syn_UnOp = Syn_UnOp {copy_Syn_UnOp :: UnOp,globalDefinitions_Syn_UnOp :: (M.Map String [Region]),identifier_Syn_UnOp :: String,isInModule_Syn_UnOp :: Bool,isNegation_Syn_UnOp :: Bool,mtokenPos_Syn_UnOp :: Region,scopes_Syn_UnOp :: ([M.Map String (Bool, Region)]),variableStyle_Syn_UnOp :: DeterminedVariableStyle,warnings_Syn_UnOp :: ([String -> LintMessage])}+wrap_UnOp :: T_UnOp ->+             Inh_UnOp ->+             Syn_UnOp+wrap_UnOp sem (Inh_UnOp _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisNegation,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_UnOp _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOisNegation _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_UnOp_UnMinus :: T_UnOp+sem_UnOp_UnMinus =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            UnMinus+            {-# LINE 13788 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13793 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_UnOp_UnMinus_1 :: T_UnOp_1+                  sem_UnOp_UnMinus_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 13810 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 13815 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 13820 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 639 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      False+                                      {-# LINE 13825 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisNegation ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 13830 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 13835 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 13840 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 13845 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisNegation,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_UnOp_UnMinus_1)) of+       { ( sem_UnOp_1) ->+       ( _lhsOcopy,sem_UnOp_1) }) }) })+sem_UnOp_ANot :: T_UnOp+sem_UnOp_ANot =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            ANot+            {-# LINE 13856 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13861 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_UnOp_ANot_1 :: T_UnOp_1+                  sem_UnOp_ANot_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 13878 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 13883 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 13888 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 641 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      True+                                      {-# LINE 13893 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisNegation ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 13898 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 13903 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 13908 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 13913 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisNegation,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_UnOp_ANot_1)) of+       { ( sem_UnOp_1) ->+       ( _lhsOcopy,sem_UnOp_1) }) }) })+sem_UnOp_AHash :: T_UnOp+sem_UnOp_AHash =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            AHash+            {-# LINE 13924 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 13929 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_UnOp_AHash_1 :: T_UnOp_1+                  sem_UnOp_AHash_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 13946 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 13951 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 13956 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 643 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      False+                                      {-# LINE 13961 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOisNegation ->+                               (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsImtokenPos+                                       {-# LINE 13966 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOmtokenPos ->+                                (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIscopes+                                        {-# LINE 13971 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOscopes ->+                                 (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         _lhsIvariableStyle+                                         {-# LINE 13976 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOvariableStyle ->+                                  (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                          []+                                          {-# LINE 13981 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                          )) of+                                   { _lhsOwarnings ->+                                   ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOisNegation,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }))+              in  sem_UnOp_AHash_1)) of+       { ( sem_UnOp_1) ->+       ( _lhsOcopy,sem_UnOp_1) }) }) })+-- VarsList ----------------------------------------------------+-- cata+sem_VarsList :: VarsList ->+                T_VarsList+sem_VarsList list =+    (Prelude.foldr sem_VarsList_Cons sem_VarsList_Nil (Prelude.map sem_Declaration list))+-- semantic domain+type T_VarsList = ( VarsList,T_VarsList_1)+type T_VarsList_1 = LintSettings ->+                    String ->+                    (M.Map String [Region]) ->+                    Bool ->+                    Bool ->+                    Bool ->+                    Int ->+                    Region ->+                    Int ->+                    ([M.Map String (Bool, Region)]) ->+                    DeterminedVariableStyle ->+                    ( (M.Map String [Region]),String,Bool,Region,([M.Map String (Bool, Region)]),DeterminedVariableStyle,([String -> LintMessage]))+data Inh_VarsList = Inh_VarsList {config_Inh_VarsList :: LintSettings,funcName_Inh_VarsList :: String,globalDefinitions_Inh_VarsList :: (M.Map String [Region]),isInModule_Inh_VarsList :: Bool,isMeta_Inh_VarsList :: Bool,localDefinition_Inh_VarsList :: Bool,loopLevel_Inh_VarsList :: Int,mtokenPos_Inh_VarsList :: Region,scopeLevel_Inh_VarsList :: Int,scopes_Inh_VarsList :: ([M.Map String (Bool, Region)]),variableStyle_Inh_VarsList :: DeterminedVariableStyle}+data Syn_VarsList = Syn_VarsList {copy_Syn_VarsList :: VarsList,globalDefinitions_Syn_VarsList :: (M.Map String [Region]),identifier_Syn_VarsList :: String,isInModule_Syn_VarsList :: Bool,mtokenPos_Syn_VarsList :: Region,scopes_Syn_VarsList :: ([M.Map String (Bool, Region)]),variableStyle_Syn_VarsList :: DeterminedVariableStyle,warnings_Syn_VarsList :: ([String -> LintMessage])}+wrap_VarsList :: T_VarsList ->+                 Inh_VarsList ->+                 Syn_VarsList+wrap_VarsList sem (Inh_VarsList _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIlocalDefinition _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle) =+    (let ( _lhsOcopy,sem_1) = sem+         ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) = sem_1 _lhsIconfig _lhsIfuncName _lhsIglobalDefinitions _lhsIisInModule _lhsIisMeta _lhsIlocalDefinition _lhsIloopLevel _lhsImtokenPos _lhsIscopeLevel _lhsIscopes _lhsIvariableStyle+     in  (Syn_VarsList _lhsOcopy _lhsOglobalDefinitions _lhsOidentifier _lhsOisInModule _lhsOmtokenPos _lhsOscopes _lhsOvariableStyle _lhsOwarnings))+sem_VarsList_Cons :: T_Declaration ->+                     T_VarsList ->+                     T_VarsList+sem_VarsList_Cons hd_ tl_ =+    (case (tl_) of+     { ( _tlIcopy,tl_1) ->+         (case (hd_) of+          { ( _hdIcopy,hd_1) ->+              (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                      (:) _hdIcopy _tlIcopy+                      {-# LINE 14027 "src/GLuaFixer/AG/ASTLint.hs" #-}+                      )) of+               { _copy ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+                       _copy+                       {-# LINE 14032 "src/GLuaFixer/AG/ASTLint.hs" #-}+                       )) of+                { _lhsOcopy ->+                (case ((let sem_VarsList_Cons_1 :: T_VarsList_1+                            sem_VarsList_Cons_1 =+                                (\ _lhsIconfig+                                   _lhsIfuncName+                                   _lhsIglobalDefinitions+                                   _lhsIisInModule+                                   _lhsIisMeta+                                   _lhsIlocalDefinition+                                   _lhsIloopLevel+                                   _lhsImtokenPos+                                   _lhsIscopeLevel+                                   _lhsIscopes+                                   _lhsIvariableStyle ->+                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                             _lhsIscopes+                                             {-# LINE 14050 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                             )) of+                                      { _hdOscopes ->+                                      (case (({-# LINE 189 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                              _lhsIlocalDefinition+                                              {-# LINE 14055 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                              )) of+                                       { _hdOlocalDefinition ->+                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                               _lhsIisMeta+                                               {-# LINE 14060 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                               )) of+                                        { _hdOisMeta ->+                                        (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                _lhsIconfig+                                                {-# LINE 14065 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                )) of+                                         { _hdOconfig ->+                                         (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                 _lhsIvariableStyle+                                                 {-# LINE 14070 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                 )) of+                                          { _hdOvariableStyle ->+                                          (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                  _lhsIscopeLevel+                                                  {-# LINE 14075 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                  )) of+                                           { _hdOscopeLevel ->+                                           (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                   _lhsImtokenPos+                                                   {-# LINE 14080 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                   )) of+                                            { _hdOmtokenPos ->+                                            (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                    _lhsIloopLevel+                                                    {-# LINE 14085 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                    )) of+                                             { _hdOloopLevel ->+                                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                     _lhsIisInModule+                                                     {-# LINE 14090 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                     )) of+                                              { _hdOisInModule ->+                                              (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                      _lhsIglobalDefinitions+                                                      {-# LINE 14095 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                      )) of+                                               { _hdOglobalDefinitions ->+                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                       _lhsIfuncName+                                                       {-# LINE 14100 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                       )) of+                                                { _hdOfuncName ->+                                                (case (hd_1 _hdOconfig _hdOfuncName _hdOglobalDefinitions _hdOisInModule _hdOisMeta _hdOlocalDefinition _hdOloopLevel _hdOmtokenPos _hdOscopeLevel _hdOscopes _hdOvariableStyle) of+                                                 { ( _hdIglobalDefinitions,_hdIidentifier,_hdIisInModule,_hdImtokenPos,_hdIscopes,_hdIvariableStyle,_hdIwarnings) ->+                                                     (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                             _hdIscopes+                                                             {-# LINE 14107 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                             )) of+                                                      { _tlOscopes ->+                                                      (case (({-# LINE 189 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                              _lhsIlocalDefinition+                                                              {-# LINE 14112 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                              )) of+                                                       { _tlOlocalDefinition ->+                                                       (case (({-# LINE 145 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                               _lhsIisMeta+                                                               {-# LINE 14117 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                               )) of+                                                        { _tlOisMeta ->+                                                        (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                _hdIisInModule+                                                                {-# LINE 14122 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                )) of+                                                         { _tlOisInModule ->+                                                         (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                 _hdIglobalDefinitions+                                                                 {-# LINE 14127 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                 )) of+                                                          { _tlOglobalDefinitions ->+                                                          (case (({-# LINE 134 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                  _lhsIconfig+                                                                  {-# LINE 14132 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                  )) of+                                                           { _tlOconfig ->+                                                           (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                   _hdIvariableStyle+                                                                   {-# LINE 14137 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                   )) of+                                                            { _tlOvariableStyle ->+                                                            (case (({-# LINE 127 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                    _lhsIscopeLevel+                                                                    {-# LINE 14142 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                    )) of+                                                             { _tlOscopeLevel ->+                                                             (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                     _hdImtokenPos+                                                                     {-# LINE 14147 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                     )) of+                                                              { _tlOmtokenPos ->+                                                              (case (({-# LINE 128 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                      _lhsIloopLevel+                                                                      {-# LINE 14152 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                      )) of+                                                               { _tlOloopLevel ->+                                                               (case (({-# LINE 146 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                       _lhsIfuncName+                                                                       {-# LINE 14157 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                       )) of+                                                                { _tlOfuncName ->+                                                                (case (tl_1 _tlOconfig _tlOfuncName _tlOglobalDefinitions _tlOisInModule _tlOisMeta _tlOlocalDefinition _tlOloopLevel _tlOmtokenPos _tlOscopeLevel _tlOscopes _tlOvariableStyle) of+                                                                 { ( _tlIglobalDefinitions,_tlIidentifier,_tlIisInModule,_tlImtokenPos,_tlIscopes,_tlIvariableStyle,_tlIwarnings) ->+                                                                     (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                             _tlIglobalDefinitions+                                                                             {-# LINE 14164 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                             )) of+                                                                      { _lhsOglobalDefinitions ->+                                                                      (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                              (const _hdIidentifier _tlIidentifier)+                                                                              {-# LINE 14169 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                              )) of+                                                                       { _lhsOidentifier ->+                                                                       (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                               _tlIisInModule+                                                                               {-# LINE 14174 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                               )) of+                                                                        { _lhsOisInModule ->+                                                                        (case (({-# LINE 234 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                _hdImtokenPos+                                                                                {-# LINE 14179 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                )) of+                                                                         { _lhsOmtokenPos ->+                                                                         (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                 _tlIscopes+                                                                                 {-# LINE 14184 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                 )) of+                                                                          { _lhsOscopes ->+                                                                          (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                  _tlIvariableStyle+                                                                                  {-# LINE 14189 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                  )) of+                                                                           { _lhsOvariableStyle ->+                                                                           (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                                                                   _hdIwarnings ++ _tlIwarnings+                                                                                   {-# LINE 14194 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                                                                   )) of+                                                                            { _lhsOwarnings ->+                                                                            ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+                        in  sem_VarsList_Cons_1)) of+                 { ( sem_VarsList_1) ->+                 ( _lhsOcopy,sem_VarsList_1) }) }) }) }) })+sem_VarsList_Nil :: T_VarsList+sem_VarsList_Nil =+    (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+            []+            {-# LINE 14205 "src/GLuaFixer/AG/ASTLint.hs" #-}+            )) of+     { _copy ->+     (case (({-# LINE 153 "src/GLuaFixer/AG/ASTLint.ag" #-}+             _copy+             {-# LINE 14210 "src/GLuaFixer/AG/ASTLint.hs" #-}+             )) of+      { _lhsOcopy ->+      (case ((let sem_VarsList_Nil_1 :: T_VarsList_1+                  sem_VarsList_Nil_1 =+                      (\ _lhsIconfig+                         _lhsIfuncName+                         _lhsIglobalDefinitions+                         _lhsIisInModule+                         _lhsIisMeta+                         _lhsIlocalDefinition+                         _lhsIloopLevel+                         _lhsImtokenPos+                         _lhsIscopeLevel+                         _lhsIscopes+                         _lhsIvariableStyle ->+                           (case (({-# LINE 138 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                   _lhsIglobalDefinitions+                                   {-# LINE 14228 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                   )) of+                            { _lhsOglobalDefinitions ->+                            (case (({-# LINE 154 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                    unknownIdentifier+                                    {-# LINE 14233 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                    )) of+                             { _lhsOidentifier ->+                             (case (({-# LINE 143 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                     _lhsIisInModule+                                     {-# LINE 14238 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                     )) of+                              { _lhsOisInModule ->+                              (case (({-# LINE 135 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                      _lhsImtokenPos+                                      {-# LINE 14243 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                      )) of+                               { _lhsOmtokenPos ->+                               (case (({-# LINE 144 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                       _lhsIscopes+                                       {-# LINE 14248 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                       )) of+                                { _lhsOscopes ->+                                (case (({-# LINE 131 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                        _lhsIvariableStyle+                                        {-# LINE 14253 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                        )) of+                                 { _lhsOvariableStyle ->+                                 (case (({-# LINE 152 "src/GLuaFixer/AG/ASTLint.ag" #-}+                                         []+                                         {-# LINE 14258 "src/GLuaFixer/AG/ASTLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOglobalDefinitions,_lhsOidentifier,_lhsOisInModule,_lhsOmtokenPos,_lhsOscopes,_lhsOvariableStyle,_lhsOwarnings) }) }) }) }) }) }) }))+              in  sem_VarsList_Nil_1)) of+       { ( sem_VarsList_1) ->+       ( _lhsOcopy,sem_VarsList_1) }) }) })
+ src/GLuaFixer/AG/LexLint.hs view
@@ -0,0 +1,6731 @@+++{-# LANGUAGE DeriveGeneric #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}++{-# OPTIONS_GHC -fno-warn-unused-binds #-}+{-# LANGUAGE CPP #-}+-- UUAGC 0.9.53.1 (src/GLuaFixer/AG/LexLint.ag)+module GLuaFixer.AG.LexLint(+    lintWarnings,+    fixedLexPositions+) where++{-# LINE 9 "src/GLuaFixer/AG/../../GLua/AG/Token.ag" #-}++import Text.ParserCombinators.UU.BasicInstances hiding (pos)+import GHC.Generics+{-# LINE 19 "src/GLuaFixer/AG/LexLint.hs" #-}++{-# LINE 15 "src/GLuaFixer/AG/LexLint.ag" #-}++import Data.List+import GLua.TokenTypes+import GLua.AG.Token+import GLuaFixer.LintMessage+import GLuaFixer.LintSettings+{-# LINE 28 "src/GLuaFixer/AG/LexLint.hs" #-}+{-# LINE 25 "src/GLuaFixer/AG/LexLint.ag" #-}+++----------------------------------------+--  C-style / Lua-style syntax inconsistencies+----------------------------------------+-- For detecting the usage of Lua/C syntax inconsistently+data SyntaxUsed = SyntaxUsed { luaUsed :: Bool, cUsed :: Bool } deriving (Show)++instance Semigroup SyntaxUsed where+    (SyntaxUsed l1 c1) <> (SyntaxUsed l2 c2) = SyntaxUsed (l1 || l2) (c1 || c2)++-- Monoid instance+instance Monoid SyntaxUsed where+    mempty = SyntaxUsed False False++mTokenWarning :: Region -> Issue -> FilePath -> LintMessage+mTokenWarning pos issue = LintMessage LintWarning pos issue++isSingleChar :: String -> Bool+isSingleChar [] = True+isSingleChar ('\\' : xs) = length xs == 1+isSingleChar (_ : []) = True+isSingleChar _ = False++-- Locate the exact position of trailing whitespace+locateTrailingWhitespace :: LineColPos -> String -> (LineColPos, String)+locateTrailingWhitespace pos (' ' : xs) = (pos, xs)+locateTrailingWhitespace pos ('\t' : xs) = (pos, xs)+locateTrailingWhitespace pos (x : xs) = locateTrailingWhitespace (customAdvanceChr pos x) xs+locateTrailingWhitespace pos [] = (pos, "")++-- Locate the start of a line's indentation in a string of whitespace+indentationStart :: LineColPos -> String -> LineColPos+indentationStart pos = go pos pos+  where+    go :: LineColPos -> LineColPos -> String -> LineColPos+    go _ cur ('\n' : xs) = let next = customAdvanceChr cur '\n' in go next next xs+    go found cur (x : xs) = go found (customAdvanceChr cur x) xs+    go found _ [] = found++endOfTrailingWhitespace :: (LineColPos, String) -> LineColPos+endOfTrailingWhitespace (pos, ('\n' : _)) = pos+endOfTrailingWhitespace (pos, (x : xs)) = endOfTrailingWhitespace (customAdvanceChr pos x, xs)+endOfTrailingWhitespace (pos, []) = pos+++{-# LINE 76 "src/GLuaFixer/AG/LexLint.hs" #-}++{-# LINE 235 "src/GLuaFixer/AG/LexLint.ag" #-}++++inh_MTokenList :: LintSettings -> Inh_MTokenList+inh_MTokenList conf =+                 Inh_MTokenList {+                    config_Inh_MTokenList                   = conf,+                    andSyntax_Inh_MTokenList                = mempty,+                    indentation_Inh_MTokenList              = mempty,+                    lineCommentSyntax_Inh_MTokenList        = mempty,+                    multilineCommentSyntax_Inh_MTokenList   = mempty,+                    neqSyntax_Inh_MTokenList                = mempty,+                    notSyntax_Inh_MTokenList                = mempty,+                    orSyntax_Inh_MTokenList                 = mempty,+                    strSyntax_Inh_MTokenList                = mempty,+                    nextTokenPos_Inh_MTokenList             = LineColPos 0 0 0+                 }++lintWarnings        :: LintSettings -> [MToken] -> [String -> LintMessage]+lintWarnings conf p = warnings_Syn_MTokenList (wrap_MTokenList (sem_MTokenList p) (inh_MTokenList conf))++-- Necessary because uu-parsinglib's LineColPos walks over tabs as though they are 8 spaces. Note+-- that this also applies when the code is lexed by the Parsec lexer.+fixedLexPositions   :: [MToken] -> [MToken]+fixedLexPositions p = copy_Syn_MTokenList (wrap_MTokenList (sem_MTokenList p) (inh_MTokenList defaultLintSettings))+{-# LINE 104 "src/GLuaFixer/AG/LexLint.hs" #-}+-- MToken ------------------------------------------------------+-- cata+sem_MToken :: MToken ->+              T_MToken+sem_MToken (MToken _mpos _mtok) =+    (sem_MToken_MToken (sem_Region _mpos) (sem_Token _mtok))+-- semantic domain+type T_MToken = SyntaxUsed ->+                LintSettings ->+                SyntaxUsed ->+                SyntaxUsed ->+                SyntaxUsed ->+                SyntaxUsed ->+                LineColPos ->+                SyntaxUsed ->+                SyntaxUsed ->+                SyntaxUsed ->+                ( SyntaxUsed,MToken,SyntaxUsed,SyntaxUsed,SyntaxUsed,SyntaxUsed,LineColPos,SyntaxUsed,SyntaxUsed,SyntaxUsed,([FilePath -> LintMessage]))+data Inh_MToken = Inh_MToken {andSyntax_Inh_MToken :: SyntaxUsed,config_Inh_MToken :: LintSettings,indentation_Inh_MToken :: SyntaxUsed,lineCommentSyntax_Inh_MToken :: SyntaxUsed,multilineCommentSyntax_Inh_MToken :: SyntaxUsed,neqSyntax_Inh_MToken :: SyntaxUsed,nextTokenPos_Inh_MToken :: LineColPos,notSyntax_Inh_MToken :: SyntaxUsed,orSyntax_Inh_MToken :: SyntaxUsed,strSyntax_Inh_MToken :: SyntaxUsed}+data Syn_MToken = Syn_MToken {andSyntax_Syn_MToken :: SyntaxUsed,copy_Syn_MToken :: MToken,indentation_Syn_MToken :: SyntaxUsed,lineCommentSyntax_Syn_MToken :: SyntaxUsed,multilineCommentSyntax_Syn_MToken :: SyntaxUsed,neqSyntax_Syn_MToken :: SyntaxUsed,nextTokenPos_Syn_MToken :: LineColPos,notSyntax_Syn_MToken :: SyntaxUsed,orSyntax_Syn_MToken :: SyntaxUsed,strSyntax_Syn_MToken :: SyntaxUsed,warnings_Syn_MToken :: ([FilePath -> LintMessage])}+wrap_MToken :: T_MToken ->+               Inh_MToken ->+               Syn_MToken+wrap_MToken sem (Inh_MToken _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax) =+    (let ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOwarnings) = sem _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax+     in  (Syn_MToken _lhsOandSyntax _lhsOcopy _lhsOindentation _lhsOlineCommentSyntax _lhsOmultilineCommentSyntax _lhsOneqSyntax _lhsOnextTokenPos _lhsOnotSyntax _lhsOorSyntax _lhsOstrSyntax _lhsOwarnings))+sem_MToken_MToken :: T_Region ->+                     T_Token ->+                     T_MToken+sem_MToken_MToken mpos_ mtok_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 77 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIconfig+                 {-# LINE 147 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _mtokOconfig ->+          (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                  _lhsIandSyntax+                  {-# LINE 152 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _mposOandSyntax ->+           (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _lhsIstrSyntax+                   {-# LINE 157 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _mposOstrSyntax ->+            (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                    _lhsIorSyntax+                    {-# LINE 162 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _mposOorSyntax ->+             (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsInotSyntax+                     {-# LINE 167 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _mposOnotSyntax ->+              (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsInextTokenPos+                      {-# LINE 172 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _mposOnextTokenPos ->+               (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsIneqSyntax+                       {-# LINE 177 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _mposOneqSyntax ->+                (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsImultilineCommentSyntax+                        {-# LINE 182 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _mposOmultilineCommentSyntax ->+                 (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsIlineCommentSyntax+                         {-# LINE 187 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _mposOlineCommentSyntax ->+                  (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIindentation+                          {-# LINE 192 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _mposOindentation ->+                   (case (({-# LINE 77 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIconfig+                           {-# LINE 197 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _mposOconfig ->+                    (case (mpos_ _mposOandSyntax _mposOconfig _mposOindentation _mposOlineCommentSyntax _mposOmultilineCommentSyntax _mposOneqSyntax _mposOnextTokenPos _mposOnotSyntax _mposOorSyntax _mposOstrSyntax) of+                     { ( _mposIandSyntax,_mposIcopy,_mposIindentation,_mposIlineCommentSyntax,_mposImultilineCommentSyntax,_mposIneqSyntax,_mposInextTokenPos,_mposInotSyntax,_mposIorSyntax,_mposIstrSyntax,_mposIwarnings) ->+                         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 _mposIandSyntax+                                 {-# LINE 204 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _mtokOandSyntax ->+                          (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  _mposIstrSyntax+                                  {-# LINE 209 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _mtokOstrSyntax ->+                           (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                                   _mposIorSyntax+                                   {-# LINE 214 "src/GLuaFixer/AG/LexLint.hs" #-}+                                   )) of+                            { _mtokOorSyntax ->+                            (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                                    _mposInotSyntax+                                    {-# LINE 219 "src/GLuaFixer/AG/LexLint.hs" #-}+                                    )) of+                             { _mtokOnotSyntax ->+                             (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                                     _mposInextTokenPos+                                     {-# LINE 224 "src/GLuaFixer/AG/LexLint.hs" #-}+                                     )) of+                              { _mtokOnextTokenPos ->+                              (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                                      _mposIneqSyntax+                                      {-# LINE 229 "src/GLuaFixer/AG/LexLint.hs" #-}+                                      )) of+                               { _mtokOneqSyntax ->+                               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                                       _mposImultilineCommentSyntax+                                       {-# LINE 234 "src/GLuaFixer/AG/LexLint.hs" #-}+                                       )) of+                                { _mtokOmultilineCommentSyntax ->+                                (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                                        _mposIlineCommentSyntax+                                        {-# LINE 239 "src/GLuaFixer/AG/LexLint.hs" #-}+                                        )) of+                                 { _mtokOlineCommentSyntax ->+                                 (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                                         _mposIindentation+                                         {-# LINE 244 "src/GLuaFixer/AG/LexLint.hs" #-}+                                         )) of+                                  { _mtokOindentation ->+                                  (case (mtok_ _mtokOandSyntax _mtokOconfig _mtokOindentation _mtokOlineCommentSyntax _mtokOmultilineCommentSyntax _mtokOneqSyntax _mtokOnextTokenPos _mtokOnotSyntax _mtokOorSyntax _mtokOstrSyntax) of+                                   { ( _mtokIandSyntax,_mtokIcopy,_mtokIcustomWarnings,_mtokIindentation,_mtokIlineCommentSyntax,_mtokImultilineCommentSyntax,_mtokIneqSyntax,_mtokInextTokenPos,_mtokInotSyntax,_mtokIorSyntax,_mtokIstrSyntax,_mtokItokenWarnings,_mtokIwarnings) ->+                                       (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                                               _mtokIandSyntax+                                               {-# LINE 251 "src/GLuaFixer/AG/LexLint.hs" #-}+                                               )) of+                                        { _lhsOandSyntax ->+                                        (case (({-# LINE 109 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                Region _lhsInextTokenPos (customAdvanceToken _lhsInextTokenPos _mtokIcopy)+                                                {-# LINE 256 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                )) of+                                         { _mpos ->+                                         (case (({-# LINE 110 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                 MToken _mpos     _mtokIcopy+                                                 {-# LINE 261 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                 )) of+                                          { _copy ->+                                          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                  _copy+                                                  {-# LINE 266 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                  )) of+                                           { _lhsOcopy ->+                                           (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                   _mtokIindentation+                                                   {-# LINE 271 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                   )) of+                                            { _lhsOindentation ->+                                            (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                    _mtokIlineCommentSyntax+                                                    {-# LINE 276 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                    )) of+                                             { _lhsOlineCommentSyntax ->+                                             (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                     _mtokImultilineCommentSyntax+                                                     {-# LINE 281 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                     )) of+                                              { _lhsOmultilineCommentSyntax ->+                                              (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                      _mtokIneqSyntax+                                                      {-# LINE 286 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                      )) of+                                               { _lhsOneqSyntax ->+                                               (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                       _mtokInextTokenPos+                                                       {-# LINE 291 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                       )) of+                                                { _lhsOnextTokenPos ->+                                                (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                        _mtokInotSyntax+                                                        {-# LINE 296 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                        )) of+                                                 { _lhsOnotSyntax ->+                                                 (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                         _mtokIorSyntax+                                                         {-# LINE 301 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                         )) of+                                                  { _lhsOorSyntax ->+                                                  (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                          _mtokIstrSyntax+                                                          {-# LINE 306 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                          )) of+                                                   { _lhsOstrSyntax ->+                                                   (case (({-# LINE 113 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                           _mtokIcustomWarnings ++ map (mTokenWarning _mpos    ) _mtokItokenWarnings+                                                           {-# LINE 311 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                           )) of+                                                    { _lhsOwarnings ->+                                                    ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+-- MTokenList --------------------------------------------------+-- cata+sem_MTokenList :: MTokenList ->+                  T_MTokenList+sem_MTokenList list =+    (Prelude.foldr sem_MTokenList_Cons sem_MTokenList_Nil (Prelude.map sem_MToken list))+-- semantic domain+type T_MTokenList = SyntaxUsed ->+                    LintSettings ->+                    SyntaxUsed ->+                    SyntaxUsed ->+                    SyntaxUsed ->+                    SyntaxUsed ->+                    LineColPos ->+                    SyntaxUsed ->+                    SyntaxUsed ->+                    SyntaxUsed ->+                    ( SyntaxUsed,MTokenList,SyntaxUsed,SyntaxUsed,SyntaxUsed,SyntaxUsed,LineColPos,SyntaxUsed,SyntaxUsed,SyntaxUsed,([FilePath -> LintMessage]))+data Inh_MTokenList = Inh_MTokenList {andSyntax_Inh_MTokenList :: SyntaxUsed,config_Inh_MTokenList :: LintSettings,indentation_Inh_MTokenList :: SyntaxUsed,lineCommentSyntax_Inh_MTokenList :: SyntaxUsed,multilineCommentSyntax_Inh_MTokenList :: SyntaxUsed,neqSyntax_Inh_MTokenList :: SyntaxUsed,nextTokenPos_Inh_MTokenList :: LineColPos,notSyntax_Inh_MTokenList :: SyntaxUsed,orSyntax_Inh_MTokenList :: SyntaxUsed,strSyntax_Inh_MTokenList :: SyntaxUsed}+data Syn_MTokenList = Syn_MTokenList {andSyntax_Syn_MTokenList :: SyntaxUsed,copy_Syn_MTokenList :: MTokenList,indentation_Syn_MTokenList :: SyntaxUsed,lineCommentSyntax_Syn_MTokenList :: SyntaxUsed,multilineCommentSyntax_Syn_MTokenList :: SyntaxUsed,neqSyntax_Syn_MTokenList :: SyntaxUsed,nextTokenPos_Syn_MTokenList :: LineColPos,notSyntax_Syn_MTokenList :: SyntaxUsed,orSyntax_Syn_MTokenList :: SyntaxUsed,strSyntax_Syn_MTokenList :: SyntaxUsed,warnings_Syn_MTokenList :: ([FilePath -> LintMessage])}+wrap_MTokenList :: T_MTokenList ->+                   Inh_MTokenList ->+                   Syn_MTokenList+wrap_MTokenList sem (Inh_MTokenList _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax) =+    (let ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOwarnings) = sem _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax+     in  (Syn_MTokenList _lhsOandSyntax _lhsOcopy _lhsOindentation _lhsOlineCommentSyntax _lhsOmultilineCommentSyntax _lhsOneqSyntax _lhsOnextTokenPos _lhsOnotSyntax _lhsOorSyntax _lhsOstrSyntax _lhsOwarnings))+sem_MTokenList_Cons :: T_MToken ->+                       T_MTokenList ->+                       T_MTokenList+sem_MTokenList_Cons hd_ tl_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 77 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIconfig+                 {-# LINE 357 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _tlOconfig ->+          (case (({-# LINE 77 "src/GLuaFixer/AG/LexLint.ag" #-}+                  _lhsIconfig+                  {-# LINE 362 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _hdOconfig ->+           (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _lhsIandSyntax+                   {-# LINE 367 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _hdOandSyntax ->+            (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                    _lhsIstrSyntax+                    {-# LINE 372 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _hdOstrSyntax ->+             (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIorSyntax+                     {-# LINE 377 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _hdOorSyntax ->+              (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsInotSyntax+                      {-# LINE 382 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _hdOnotSyntax ->+               (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsInextTokenPos+                       {-# LINE 387 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _hdOnextTokenPos ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 392 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _hdOneqSyntax ->+                 (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsImultilineCommentSyntax+                         {-# LINE 397 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _hdOmultilineCommentSyntax ->+                  (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIlineCommentSyntax+                          {-# LINE 402 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _hdOlineCommentSyntax ->+                   (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIindentation+                           {-# LINE 407 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _hdOindentation ->+                    (case (hd_ _hdOandSyntax _hdOconfig _hdOindentation _hdOlineCommentSyntax _hdOmultilineCommentSyntax _hdOneqSyntax _hdOnextTokenPos _hdOnotSyntax _hdOorSyntax _hdOstrSyntax) of+                     { ( _hdIandSyntax,_hdIcopy,_hdIindentation,_hdIlineCommentSyntax,_hdImultilineCommentSyntax,_hdIneqSyntax,_hdInextTokenPos,_hdInotSyntax,_hdIorSyntax,_hdIstrSyntax,_hdIwarnings) ->+                         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 _hdIandSyntax+                                 {-# LINE 414 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _tlOandSyntax ->+                          (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  _hdIstrSyntax+                                  {-# LINE 419 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _tlOstrSyntax ->+                           (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                                   _hdIorSyntax+                                   {-# LINE 424 "src/GLuaFixer/AG/LexLint.hs" #-}+                                   )) of+                            { _tlOorSyntax ->+                            (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                                    _hdInotSyntax+                                    {-# LINE 429 "src/GLuaFixer/AG/LexLint.hs" #-}+                                    )) of+                             { _tlOnotSyntax ->+                             (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                                     _hdInextTokenPos+                                     {-# LINE 434 "src/GLuaFixer/AG/LexLint.hs" #-}+                                     )) of+                              { _tlOnextTokenPos ->+                              (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                                      _hdIneqSyntax+                                      {-# LINE 439 "src/GLuaFixer/AG/LexLint.hs" #-}+                                      )) of+                               { _tlOneqSyntax ->+                               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                                       _hdImultilineCommentSyntax+                                       {-# LINE 444 "src/GLuaFixer/AG/LexLint.hs" #-}+                                       )) of+                                { _tlOmultilineCommentSyntax ->+                                (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                                        _hdIlineCommentSyntax+                                        {-# LINE 449 "src/GLuaFixer/AG/LexLint.hs" #-}+                                        )) of+                                 { _tlOlineCommentSyntax ->+                                 (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                                         _hdIindentation+                                         {-# LINE 454 "src/GLuaFixer/AG/LexLint.hs" #-}+                                         )) of+                                  { _tlOindentation ->+                                  (case (tl_ _tlOandSyntax _tlOconfig _tlOindentation _tlOlineCommentSyntax _tlOmultilineCommentSyntax _tlOneqSyntax _tlOnextTokenPos _tlOnotSyntax _tlOorSyntax _tlOstrSyntax) of+                                   { ( _tlIandSyntax,_tlIcopy,_tlIindentation,_tlIlineCommentSyntax,_tlImultilineCommentSyntax,_tlIneqSyntax,_tlInextTokenPos,_tlInotSyntax,_tlIorSyntax,_tlIstrSyntax,_tlIwarnings) ->+                                       (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                                               _tlIandSyntax+                                               {-# LINE 461 "src/GLuaFixer/AG/LexLint.hs" #-}+                                               )) of+                                        { _lhsOandSyntax ->+                                        (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                (:) _hdIcopy _tlIcopy+                                                {-# LINE 466 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                )) of+                                         { _copy ->+                                         (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                 _copy+                                                 {-# LINE 471 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                 )) of+                                          { _lhsOcopy ->+                                          (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                  _tlIindentation+                                                  {-# LINE 476 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                  )) of+                                           { _lhsOindentation ->+                                           (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                   _tlIlineCommentSyntax+                                                   {-# LINE 481 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                   )) of+                                            { _lhsOlineCommentSyntax ->+                                            (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                    _tlImultilineCommentSyntax+                                                    {-# LINE 486 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                    )) of+                                             { _lhsOmultilineCommentSyntax ->+                                             (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                     _tlIneqSyntax+                                                     {-# LINE 491 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                     )) of+                                              { _lhsOneqSyntax ->+                                              (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                      _tlInextTokenPos+                                                      {-# LINE 496 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                      )) of+                                               { _lhsOnextTokenPos ->+                                               (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                       _tlInotSyntax+                                                       {-# LINE 501 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                       )) of+                                                { _lhsOnotSyntax ->+                                                (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                        _tlIorSyntax+                                                        {-# LINE 506 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                        )) of+                                                 { _lhsOorSyntax ->+                                                 (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                         _tlIstrSyntax+                                                         {-# LINE 511 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                         )) of+                                                  { _lhsOstrSyntax ->+                                                  (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                          _hdIwarnings ++ _tlIwarnings+                                                          {-# LINE 516 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                          )) of+                                                   { _lhsOwarnings ->+                                                   ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_MTokenList_Nil :: T_MTokenList+sem_MTokenList_Nil =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 534 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  []+                  {-# LINE 539 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 544 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                    _lhsIindentation+                    {-# LINE 549 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOindentation ->+             (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIlineCommentSyntax+                     {-# LINE 554 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOlineCommentSyntax ->+              (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsImultilineCommentSyntax+                      {-# LINE 559 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOmultilineCommentSyntax ->+               (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsIneqSyntax+                       {-# LINE 564 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOneqSyntax ->+                (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsInextTokenPos+                        {-# LINE 569 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOnextTokenPos ->+                 (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsInotSyntax+                         {-# LINE 574 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnotSyntax ->+                  (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIorSyntax+                          {-# LINE 579 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOorSyntax ->+                   (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIstrSyntax+                           {-# LINE 584 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOstrSyntax ->+                    (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                            []+                            {-# LINE 589 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOwarnings ->+                     ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }))+-- Region ------------------------------------------------------+-- cata+sem_Region :: Region ->+              T_Region+sem_Region (Region _start _end) =+    (sem_Region_Region _start _end)+-- semantic domain+type T_Region = SyntaxUsed ->+                LintSettings ->+                SyntaxUsed ->+                SyntaxUsed ->+                SyntaxUsed ->+                SyntaxUsed ->+                LineColPos ->+                SyntaxUsed ->+                SyntaxUsed ->+                SyntaxUsed ->+                ( SyntaxUsed,Region,SyntaxUsed,SyntaxUsed,SyntaxUsed,SyntaxUsed,LineColPos,SyntaxUsed,SyntaxUsed,SyntaxUsed,([FilePath -> LintMessage]))+data Inh_Region = Inh_Region {andSyntax_Inh_Region :: SyntaxUsed,config_Inh_Region :: LintSettings,indentation_Inh_Region :: SyntaxUsed,lineCommentSyntax_Inh_Region :: SyntaxUsed,multilineCommentSyntax_Inh_Region :: SyntaxUsed,neqSyntax_Inh_Region :: SyntaxUsed,nextTokenPos_Inh_Region :: LineColPos,notSyntax_Inh_Region :: SyntaxUsed,orSyntax_Inh_Region :: SyntaxUsed,strSyntax_Inh_Region :: SyntaxUsed}+data Syn_Region = Syn_Region {andSyntax_Syn_Region :: SyntaxUsed,copy_Syn_Region :: Region,indentation_Syn_Region :: SyntaxUsed,lineCommentSyntax_Syn_Region :: SyntaxUsed,multilineCommentSyntax_Syn_Region :: SyntaxUsed,neqSyntax_Syn_Region :: SyntaxUsed,nextTokenPos_Syn_Region :: LineColPos,notSyntax_Syn_Region :: SyntaxUsed,orSyntax_Syn_Region :: SyntaxUsed,strSyntax_Syn_Region :: SyntaxUsed,warnings_Syn_Region :: ([FilePath -> LintMessage])}+wrap_Region :: T_Region ->+               Inh_Region ->+               Syn_Region+wrap_Region sem (Inh_Region _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax) =+    (let ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOwarnings) = sem _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax+     in  (Syn_Region _lhsOandSyntax _lhsOcopy _lhsOindentation _lhsOlineCommentSyntax _lhsOmultilineCommentSyntax _lhsOneqSyntax _lhsOnextTokenPos _lhsOnotSyntax _lhsOorSyntax _lhsOstrSyntax _lhsOwarnings))+sem_Region_Region :: LineColPos ->+                     LineColPos ->+                     T_Region+sem_Region_Region start_ end_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 635 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Region start_ end_+                  {-# LINE 640 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 645 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                    _lhsIindentation+                    {-# LINE 650 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOindentation ->+             (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIlineCommentSyntax+                     {-# LINE 655 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOlineCommentSyntax ->+              (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsImultilineCommentSyntax+                      {-# LINE 660 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOmultilineCommentSyntax ->+               (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsIneqSyntax+                       {-# LINE 665 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOneqSyntax ->+                (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsInextTokenPos+                        {-# LINE 670 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOnextTokenPos ->+                 (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsInotSyntax+                         {-# LINE 675 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnotSyntax ->+                  (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIorSyntax+                          {-# LINE 680 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOorSyntax ->+                   (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIstrSyntax+                           {-# LINE 685 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOstrSyntax ->+                    (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                            []+                            {-# LINE 690 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOwarnings ->+                     ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }))+-- Token -------------------------------------------------------+-- cata+sem_Token :: Token ->+             T_Token+sem_Token (Whitespace _space) =+    (sem_Token_Whitespace _space)+sem_Token (DashComment _comment) =+    (sem_Token_DashComment _comment)+sem_Token (DashBlockComment _depth _comment) =+    (sem_Token_DashBlockComment _depth _comment)+sem_Token (SlashComment _comment) =+    (sem_Token_SlashComment _comment)+sem_Token (SlashBlockComment _comment) =+    (sem_Token_SlashBlockComment _comment)+sem_Token (Semicolon) =+    (sem_Token_Semicolon)+sem_Token (TNumber _num) =+    (sem_Token_TNumber _num)+sem_Token (DQString _str) =+    (sem_Token_DQString _str)+sem_Token (SQString _str) =+    (sem_Token_SQString _str)+sem_Token (MLString _str) =+    (sem_Token_MLString _str)+sem_Token (TTrue) =+    (sem_Token_TTrue)+sem_Token (TFalse) =+    (sem_Token_TFalse)+sem_Token (Nil) =+    (sem_Token_Nil)+sem_Token (VarArg) =+    (sem_Token_VarArg)+sem_Token (Plus) =+    (sem_Token_Plus)+sem_Token (Minus) =+    (sem_Token_Minus)+sem_Token (Multiply) =+    (sem_Token_Multiply)+sem_Token (Divide) =+    (sem_Token_Divide)+sem_Token (Modulus) =+    (sem_Token_Modulus)+sem_Token (Power) =+    (sem_Token_Power)+sem_Token (TEq) =+    (sem_Token_TEq)+sem_Token (TNEq) =+    (sem_Token_TNEq)+sem_Token (TCNEq) =+    (sem_Token_TCNEq)+sem_Token (TLEQ) =+    (sem_Token_TLEQ)+sem_Token (TGEQ) =+    (sem_Token_TGEQ)+sem_Token (TLT) =+    (sem_Token_TLT)+sem_Token (TGT) =+    (sem_Token_TGT)+sem_Token (Equals) =+    (sem_Token_Equals)+sem_Token (Concatenate) =+    (sem_Token_Concatenate)+sem_Token (Colon) =+    (sem_Token_Colon)+sem_Token (Dot) =+    (sem_Token_Dot)+sem_Token (Comma) =+    (sem_Token_Comma)+sem_Token (Hash) =+    (sem_Token_Hash)+sem_Token (Not) =+    (sem_Token_Not)+sem_Token (CNot) =+    (sem_Token_CNot)+sem_Token (And) =+    (sem_Token_And)+sem_Token (CAnd) =+    (sem_Token_CAnd)+sem_Token (Or) =+    (sem_Token_Or)+sem_Token (COr) =+    (sem_Token_COr)+sem_Token (Function) =+    (sem_Token_Function)+sem_Token (Local) =+    (sem_Token_Local)+sem_Token (If) =+    (sem_Token_If)+sem_Token (Then) =+    (sem_Token_Then)+sem_Token (Elseif) =+    (sem_Token_Elseif)+sem_Token (Else) =+    (sem_Token_Else)+sem_Token (For) =+    (sem_Token_For)+sem_Token (In) =+    (sem_Token_In)+sem_Token (Do) =+    (sem_Token_Do)+sem_Token (While) =+    (sem_Token_While)+sem_Token (Until) =+    (sem_Token_Until)+sem_Token (Repeat) =+    (sem_Token_Repeat)+sem_Token (Continue) =+    (sem_Token_Continue)+sem_Token (Break) =+    (sem_Token_Break)+sem_Token (Return) =+    (sem_Token_Return)+sem_Token (End) =+    (sem_Token_End)+sem_Token (LRound) =+    (sem_Token_LRound)+sem_Token (RRound) =+    (sem_Token_RRound)+sem_Token (LCurly) =+    (sem_Token_LCurly)+sem_Token (RCurly) =+    (sem_Token_RCurly)+sem_Token (LSquare) =+    (sem_Token_LSquare)+sem_Token (RSquare) =+    (sem_Token_RSquare)+sem_Token (Label _lbl) =+    (sem_Token_Label _lbl)+sem_Token (Identifier _ident) =+    (sem_Token_Identifier _ident)+-- semantic domain+type T_Token = SyntaxUsed ->+               LintSettings ->+               SyntaxUsed ->+               SyntaxUsed ->+               SyntaxUsed ->+               SyntaxUsed ->+               LineColPos ->+               SyntaxUsed ->+               SyntaxUsed ->+               SyntaxUsed ->+               ( SyntaxUsed,Token,([FilePath -> LintMessage]),SyntaxUsed,SyntaxUsed,SyntaxUsed,SyntaxUsed,LineColPos,SyntaxUsed,SyntaxUsed,SyntaxUsed,([Issue]),([FilePath -> LintMessage]))+data Inh_Token = Inh_Token {andSyntax_Inh_Token :: SyntaxUsed,config_Inh_Token :: LintSettings,indentation_Inh_Token :: SyntaxUsed,lineCommentSyntax_Inh_Token :: SyntaxUsed,multilineCommentSyntax_Inh_Token :: SyntaxUsed,neqSyntax_Inh_Token :: SyntaxUsed,nextTokenPos_Inh_Token :: LineColPos,notSyntax_Inh_Token :: SyntaxUsed,orSyntax_Inh_Token :: SyntaxUsed,strSyntax_Inh_Token :: SyntaxUsed}+data Syn_Token = Syn_Token {andSyntax_Syn_Token :: SyntaxUsed,copy_Syn_Token :: Token,customWarnings_Syn_Token :: ([FilePath -> LintMessage]),indentation_Syn_Token :: SyntaxUsed,lineCommentSyntax_Syn_Token :: SyntaxUsed,multilineCommentSyntax_Syn_Token :: SyntaxUsed,neqSyntax_Syn_Token :: SyntaxUsed,nextTokenPos_Syn_Token :: LineColPos,notSyntax_Syn_Token :: SyntaxUsed,orSyntax_Syn_Token :: SyntaxUsed,strSyntax_Syn_Token :: SyntaxUsed,tokenWarnings_Syn_Token :: ([Issue]),warnings_Syn_Token :: ([FilePath -> LintMessage])}+wrap_Token :: T_Token ->+              Inh_Token ->+              Syn_Token+wrap_Token sem (Inh_Token _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax) =+    (let ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) = sem _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax+     in  (Syn_Token _lhsOandSyntax _lhsOcopy _lhsOcustomWarnings _lhsOindentation _lhsOlineCommentSyntax _lhsOmultilineCommentSyntax _lhsOneqSyntax _lhsOnextTokenPos _lhsOnotSyntax _lhsOorSyntax _lhsOstrSyntax _lhsOtokenWarnings _lhsOwarnings))+sem_Token_Whitespace :: String ->+                        T_Token+sem_Token_Whitespace space_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 859 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Whitespace space_+                  {-# LINE 864 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 869 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 132 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 874 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _customWarnings_augmented_syn ->+             (case (({-# LINE 117 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsInextTokenPos+                     {-# LINE 879 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _curTokenPos ->+              (case (({-# LINE 118 "src/GLuaFixer/AG/LexLint.ag" #-}+                      customAdvanceStr _curTokenPos     space_+                      {-# LINE 884 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _nextTokenPos ->+               (case (({-# LINE 128 "src/GLuaFixer/AG/LexLint.ag" #-}+                       Region (indentationStart _curTokenPos     space_) _nextTokenPos+                       {-# LINE 889 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _indentationRg ->+                (case (({-# LINE 124 "src/GLuaFixer/AG/LexLint.ag" #-}+                        locateTrailingWhitespace _curTokenPos     space_+                        {-# LINE 894 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _whitespaceStart ->+                 (case (({-# LINE 125 "src/GLuaFixer/AG/LexLint.ag" #-}+                         endOfTrailingWhitespace _whitespaceStart+                         {-# LINE 899 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _whitespaceEnd ->+                  (case (({-# LINE 120 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIindentation <> SyntaxUsed (isInfixOf "\n " space_) (isInfixOf "\n\t" space_)+                          {-# LINE 904 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _whitespaceUsed ->+                   (case (({-# LINE 121 "src/GLuaFixer/AG/LexLint.ag" #-}+                           luaUsed _whitespaceUsed     && cUsed _whitespaceUsed+                           {-# LINE 909 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _inconsistent ->+                    (case (({-# LINE 132 "src/GLuaFixer/AG/LexLint.ag" #-}+                            if not (lint_trailingWhitespace _lhsIconfig) || (not (isInfixOf " \n" space_) && not (isInfixOf "\t\n" space_)) then id else (:) $ mTokenWarning (Region (fst _whitespaceStart    ) _whitespaceEnd    ) TrailingWhitespace+                            {-# LINE 914 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _customWarnings_augmented_f2 ->+                     (case (({-# LINE 132 "src/GLuaFixer/AG/LexLint.ag" #-}+                             if not (lint_whitespaceStyle _lhsIconfig) || not _inconsistent     then id else+                               (:) $ mTokenWarning _indentationRg     InconsistentTabsSpaces+                             {-# LINE 920 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _customWarnings_augmented_f1 ->+                      (case (({-# LINE 132 "src/GLuaFixer/AG/LexLint.ag" #-}+                              foldr ($) _customWarnings_augmented_syn [_customWarnings_augmented_f1, _customWarnings_augmented_f2]+                              {-# LINE 925 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOcustomWarnings ->+                       (case (({-# LINE 119 "src/GLuaFixer/AG/LexLint.ag" #-}+                               if _inconsistent     then mempty else _whitespaceUsed+                               {-# LINE 930 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _indentation ->+                        (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                                _indentation+                                {-# LINE 935 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _lhsOindentation ->+                         (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 _lhsIlineCommentSyntax+                                 {-# LINE 940 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOlineCommentSyntax ->+                          (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  _lhsImultilineCommentSyntax+                                  {-# LINE 945 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOmultilineCommentSyntax ->+                           (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                                   _lhsIneqSyntax+                                   {-# LINE 950 "src/GLuaFixer/AG/LexLint.hs" #-}+                                   )) of+                            { _lhsOneqSyntax ->+                            (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                                    _nextTokenPos+                                    {-# LINE 955 "src/GLuaFixer/AG/LexLint.hs" #-}+                                    )) of+                             { _lhsOnextTokenPos ->+                             (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                                     _lhsInotSyntax+                                     {-# LINE 960 "src/GLuaFixer/AG/LexLint.hs" #-}+                                     )) of+                              { _lhsOnotSyntax ->+                              (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                                      _lhsIorSyntax+                                      {-# LINE 965 "src/GLuaFixer/AG/LexLint.hs" #-}+                                      )) of+                               { _lhsOorSyntax ->+                               (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                                       _lhsIstrSyntax+                                       {-# LINE 970 "src/GLuaFixer/AG/LexLint.hs" #-}+                                       )) of+                                { _lhsOstrSyntax ->+                                (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                                        []+                                        {-# LINE 975 "src/GLuaFixer/AG/LexLint.hs" #-}+                                        )) of+                                 { _lhsOtokenWarnings ->+                                 (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                         []+                                         {-# LINE 980 "src/GLuaFixer/AG/LexLint.hs" #-}+                                         )) of+                                  { _lhsOwarnings ->+                                  ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_DashComment :: String ->+                         T_Token+sem_Token_DashComment comment_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 999 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  DashComment comment_+                  {-# LINE 1004 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1009 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1014 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1019 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 137 "src/GLuaFixer/AG/LexLint.ag" #-}+                      (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . cUsed $ _lhsIlineCommentSyntax)+                      {-# LINE 1024 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _consistent ->+               (case (({-# LINE 138 "src/GLuaFixer/AG/LexLint.ag" #-}+                       SyntaxUsed _consistent     False+                       {-# LINE 1029 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lineCommentSyntax ->+                (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lineCommentSyntax+                        {-# LINE 1034 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOlineCommentSyntax ->+                 (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsImultilineCommentSyntax+                         {-# LINE 1039 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOmultilineCommentSyntax ->+                  (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIneqSyntax+                          {-# LINE 1044 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOneqSyntax ->+                   (case (({-# LINE 136 "src/GLuaFixer/AG/LexLint.ag" #-}+                           customAdvanceToken _lhsInextTokenPos _copy+                           {-# LINE 1049 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOnextTokenPos ->+                    (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsInotSyntax+                            {-# LINE 1054 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnotSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsIorSyntax+                             {-# LINE 1059 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 1064 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 139 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 1069 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 139 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "--" "//"+                                {-# LINE 1075 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 139 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 1080 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 1085 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_DashBlockComment :: Int ->+                              String ->+                              T_Token+sem_Token_DashBlockComment depth_ comment_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1105 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  DashBlockComment depth_ comment_+                  {-# LINE 1110 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1115 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1120 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1125 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1130 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 153 "src/GLuaFixer/AG/LexLint.ag" #-}+                       (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . cUsed $ _lhsImultilineCommentSyntax)+                       {-# LINE 1135 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _consistent ->+                (case (({-# LINE 154 "src/GLuaFixer/AG/LexLint.ag" #-}+                        SyntaxUsed _consistent     False+                        {-# LINE 1140 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _multilineCommentSyntax ->+                 (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _multilineCommentSyntax+                         {-# LINE 1145 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOmultilineCommentSyntax ->+                  (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIneqSyntax+                          {-# LINE 1150 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOneqSyntax ->+                   (case (({-# LINE 151 "src/GLuaFixer/AG/LexLint.ag" #-}+                           showString "--[" . showString (replicate depth_ '-') . showChar '[' . showString comment_ . showChar ']' . showString (replicate depth_ '-') . showChar ']' $ ""+                           {-# LINE 1155 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _str ->+                    (case (({-# LINE 152 "src/GLuaFixer/AG/LexLint.ag" #-}+                            customAdvanceStr _lhsInextTokenPos _str+                            {-# LINE 1160 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnextTokenPos ->+                     (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsInotSyntax+                             {-# LINE 1165 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOnotSyntax ->+                      (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIorSyntax+                              {-# LINE 1170 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOorSyntax ->+                       (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                               _lhsIstrSyntax+                               {-# LINE 1175 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _lhsOstrSyntax ->+                        (case (({-# LINE 155 "src/GLuaFixer/AG/LexLint.ag" #-}+                                []+                                {-# LINE 1180 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_syn ->+                         (case (({-# LINE 155 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 if _consistent     then id else+                                    (:) $ SyntaxInconsistency "--[[ ]]" "/* */"+                                 {-# LINE 1186 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _tokenWarnings_augmented_f1 ->+                          (case (({-# LINE 155 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                  {-# LINE 1191 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOtokenWarnings ->+                           (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                   []+                                   {-# LINE 1196 "src/GLuaFixer/AG/LexLint.hs" #-}+                                   )) of+                            { _lhsOwarnings ->+                            ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_SlashComment :: String ->+                          T_Token+sem_Token_SlashComment comment_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1215 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  SlashComment comment_+                  {-# LINE 1220 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1225 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1230 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1235 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 144 "src/GLuaFixer/AG/LexLint.ag" #-}+                      (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . luaUsed $ _lhsIlineCommentSyntax)+                      {-# LINE 1240 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _consistent ->+               (case (({-# LINE 145 "src/GLuaFixer/AG/LexLint.ag" #-}+                       SyntaxUsed False _consistent+                       {-# LINE 1245 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lineCommentSyntax ->+                (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lineCommentSyntax+                        {-# LINE 1250 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOlineCommentSyntax ->+                 (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsImultilineCommentSyntax+                         {-# LINE 1255 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOmultilineCommentSyntax ->+                  (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIneqSyntax+                          {-# LINE 1260 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOneqSyntax ->+                   (case (({-# LINE 143 "src/GLuaFixer/AG/LexLint.ag" #-}+                           customAdvanceToken _lhsInextTokenPos _copy+                           {-# LINE 1265 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOnextTokenPos ->+                    (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsInotSyntax+                            {-# LINE 1270 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnotSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsIorSyntax+                             {-# LINE 1275 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 1280 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 146 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 1285 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 146 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "//" "--"+                                {-# LINE 1291 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 146 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 1296 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 1301 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_SlashBlockComment :: String ->+                               T_Token+sem_Token_SlashBlockComment comment_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1320 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  SlashBlockComment comment_+                  {-# LINE 1325 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1330 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1335 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1340 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1345 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 161 "src/GLuaFixer/AG/LexLint.ag" #-}+                       (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . luaUsed $ _lhsImultilineCommentSyntax)+                       {-# LINE 1350 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _consistent ->+                (case (({-# LINE 162 "src/GLuaFixer/AG/LexLint.ag" #-}+                        SyntaxUsed False _consistent+                        {-# LINE 1355 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _multilineCommentSyntax ->+                 (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _multilineCommentSyntax+                         {-# LINE 1360 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOmultilineCommentSyntax ->+                  (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIneqSyntax+                          {-# LINE 1365 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOneqSyntax ->+                   (case (({-# LINE 159 "src/GLuaFixer/AG/LexLint.ag" #-}+                           showString "/*" . showString comment_ . showString "*/" $ ""+                           {-# LINE 1370 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _str ->+                    (case (({-# LINE 160 "src/GLuaFixer/AG/LexLint.ag" #-}+                            customAdvanceStr _lhsInextTokenPos _str+                            {-# LINE 1375 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnextTokenPos ->+                     (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsInotSyntax+                             {-# LINE 1380 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOnotSyntax ->+                      (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIorSyntax+                              {-# LINE 1385 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOorSyntax ->+                       (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                               _lhsIstrSyntax+                               {-# LINE 1390 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _lhsOstrSyntax ->+                        (case (({-# LINE 163 "src/GLuaFixer/AG/LexLint.ag" #-}+                                []+                                {-# LINE 1395 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_syn ->+                         (case (({-# LINE 163 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 if _consistent     then id else+                                    (:) $ SyntaxInconsistency "/* */" "--[[ ]]"+                                 {-# LINE 1401 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _tokenWarnings_augmented_f1 ->+                          (case (({-# LINE 163 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                  {-# LINE 1406 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOtokenWarnings ->+                           (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                   []+                                   {-# LINE 1411 "src/GLuaFixer/AG/LexLint.hs" #-}+                                   )) of+                            { _lhsOwarnings ->+                            ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Semicolon :: T_Token+sem_Token_Semicolon =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1429 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Semicolon+                  {-# LINE 1434 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1439 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1444 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1449 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1454 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 1459 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 1464 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 1469 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 1474 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 1479 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 1484 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 1489 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 1494 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TNumber :: String ->+                     T_Token+sem_Token_TNumber num_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1513 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TNumber num_+                  {-# LINE 1518 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1523 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1528 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1533 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1538 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 1543 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 1548 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 1553 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 1558 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 1563 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 1568 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 1573 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 1578 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_DQString :: String ->+                      T_Token+sem_Token_DQString str_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1597 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  DQString str_+                  {-# LINE 1602 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1607 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1612 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1617 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1622 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 1627 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 1632 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 1637 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 1642 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 1647 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 170 "src/GLuaFixer/AG/LexLint.ag" #-}+                            (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . cUsed $ _lhsIstrSyntax)+                            {-# LINE 1652 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _consistent ->+                     (case (({-# LINE 171 "src/GLuaFixer/AG/LexLint.ag" #-}+                             SyntaxUsed _consistent     False+                             {-# LINE 1657 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _strSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _strSyntax+                              {-# LINE 1662 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 172 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 1667 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 172 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "double quoted strings" "single quoted strings"+                                {-# LINE 1673 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 172 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 1678 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 1683 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_SQString :: String ->+                      T_Token+sem_Token_SQString str_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1702 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  SQString str_+                  {-# LINE 1707 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1712 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1717 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1722 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1727 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 1732 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 1737 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 1742 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 1747 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 1752 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 176 "src/GLuaFixer/AG/LexLint.ag" #-}+                            (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . luaUsed $ _lhsIstrSyntax) || isSingleChar str_+                            {-# LINE 1757 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _consistent ->+                     (case (({-# LINE 177 "src/GLuaFixer/AG/LexLint.ag" #-}+                             SyntaxUsed False (_consistent     && not (isSingleChar str_))+                             {-# LINE 1762 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _strSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _strSyntax+                              {-# LINE 1767 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 178 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 1772 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 178 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "single quoted strings" "double quoted strings"+                                {-# LINE 1778 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 178 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 1783 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 1788 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_MLString :: String ->+                      T_Token+sem_Token_MLString str_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1807 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  MLString str_+                  {-# LINE 1812 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1817 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1822 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1827 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1832 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 1837 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 1842 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 182 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceStr _lhsInextTokenPos str_+                         {-# LINE 1847 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 1852 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 1857 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 1862 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 1867 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 1872 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TTrue :: T_Token+sem_Token_TTrue =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1890 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TTrue+                  {-# LINE 1895 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1900 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1905 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1910 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1915 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 1920 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 1925 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 1930 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 1935 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 1940 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 1945 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 1950 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 1955 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TFalse :: T_Token+sem_Token_TFalse =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 1973 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TFalse+                  {-# LINE 1978 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 1983 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 1988 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 1993 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 1998 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2003 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2008 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2013 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2018 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2023 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2028 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2033 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2038 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Nil :: T_Token+sem_Token_Nil =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2056 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Nil+                  {-# LINE 2061 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2066 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2071 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2076 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2081 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2086 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2091 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2096 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2101 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2106 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2111 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2116 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2121 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_VarArg :: T_Token+sem_Token_VarArg =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2139 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  VarArg+                  {-# LINE 2144 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2149 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2154 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2159 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2164 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2169 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2174 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2179 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2184 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2189 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2194 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2199 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2204 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Plus :: T_Token+sem_Token_Plus =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2222 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Plus+                  {-# LINE 2227 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2232 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2237 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2242 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2247 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2252 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2257 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2262 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2267 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2272 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2277 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2282 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2287 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Minus :: T_Token+sem_Token_Minus =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2305 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Minus+                  {-# LINE 2310 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2315 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2320 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2325 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2330 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2335 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2340 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2345 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2350 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2355 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2360 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2365 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2370 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Multiply :: T_Token+sem_Token_Multiply =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2388 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Multiply+                  {-# LINE 2393 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2398 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2403 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2408 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2413 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2418 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2423 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2428 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2433 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2438 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2443 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2448 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2453 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Divide :: T_Token+sem_Token_Divide =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2471 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Divide+                  {-# LINE 2476 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2481 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2486 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2491 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2496 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2501 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2506 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2511 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2516 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2521 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2526 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2531 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2536 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Modulus :: T_Token+sem_Token_Modulus =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2554 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Modulus+                  {-# LINE 2559 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2564 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2569 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2574 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2579 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2584 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2589 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2594 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2599 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2604 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2609 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2614 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2619 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Power :: T_Token+sem_Token_Power =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2637 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Power+                  {-# LINE 2642 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2647 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2652 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2657 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2662 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2667 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2672 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2677 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2682 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2687 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2692 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2697 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2702 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TEq :: T_Token+sem_Token_TEq =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2720 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TEq+                  {-# LINE 2725 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2730 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2735 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2740 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2745 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2750 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 2755 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 2760 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 2765 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 2770 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 2775 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 2780 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 2785 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TNEq :: T_Token+sem_Token_TNEq =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2803 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TNEq+                  {-# LINE 2808 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2813 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2818 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2823 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2828 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2833 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 221 "src/GLuaFixer/AG/LexLint.ag" #-}+                        (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . cUsed $ _lhsIneqSyntax)+                        {-# LINE 2838 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _consistent ->+                 (case (({-# LINE 222 "src/GLuaFixer/AG/LexLint.ag" #-}+                         SyntaxUsed _consistent     False+                         {-# LINE 2843 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _neqSyntax ->+                  (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _neqSyntax+                          {-# LINE 2848 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOneqSyntax ->+                   (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                           customAdvanceToken _lhsInextTokenPos _copy+                           {-# LINE 2853 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOnextTokenPos ->+                    (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsInotSyntax+                            {-# LINE 2858 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnotSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsIorSyntax+                             {-# LINE 2863 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 2868 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 223 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 2873 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 223 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "~=" "!="+                                {-# LINE 2879 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 223 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 2884 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 2889 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TCNEq :: T_Token+sem_Token_TCNEq =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 2907 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TCNEq+                  {-# LINE 2912 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 2917 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 2922 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 2927 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 2932 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 2937 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 227 "src/GLuaFixer/AG/LexLint.ag" #-}+                        (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . luaUsed $ _lhsIneqSyntax)+                        {-# LINE 2942 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _consistent ->+                 (case (({-# LINE 228 "src/GLuaFixer/AG/LexLint.ag" #-}+                         SyntaxUsed False _consistent+                         {-# LINE 2947 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _neqSyntax ->+                  (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _neqSyntax+                          {-# LINE 2952 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOneqSyntax ->+                   (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                           customAdvanceToken _lhsInextTokenPos _copy+                           {-# LINE 2957 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOnextTokenPos ->+                    (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsInotSyntax+                            {-# LINE 2962 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnotSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsIorSyntax+                             {-# LINE 2967 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 2972 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 229 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 2977 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 229 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "!=" "~="+                                {-# LINE 2983 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 229 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 2988 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 2993 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TLEQ :: T_Token+sem_Token_TLEQ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3011 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TLEQ+                  {-# LINE 3016 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3021 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3026 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3031 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3036 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3041 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3046 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3051 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3056 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3061 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3066 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3071 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3076 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TGEQ :: T_Token+sem_Token_TGEQ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3094 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TGEQ+                  {-# LINE 3099 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3104 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3109 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3114 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3119 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3124 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3129 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3134 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3139 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3144 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3149 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3154 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3159 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TLT :: T_Token+sem_Token_TLT =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3177 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TLT+                  {-# LINE 3182 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3187 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3192 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3197 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3202 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3207 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3212 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3217 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3222 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3227 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3232 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3237 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3242 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_TGT :: T_Token+sem_Token_TGT =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3260 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  TGT+                  {-# LINE 3265 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3270 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3275 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3280 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3285 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3290 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3295 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3300 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3305 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3310 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3315 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3320 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3325 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Equals :: T_Token+sem_Token_Equals =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3343 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Equals+                  {-# LINE 3348 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3353 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3358 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3363 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3368 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3373 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3378 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3383 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3388 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3393 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3398 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3403 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3408 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Concatenate :: T_Token+sem_Token_Concatenate =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3426 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Concatenate+                  {-# LINE 3431 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3436 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3441 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3446 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3451 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3456 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3461 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3466 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3471 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3476 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3481 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3486 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3491 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Colon :: T_Token+sem_Token_Colon =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3509 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Colon+                  {-# LINE 3514 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3519 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3524 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3529 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3534 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3539 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3544 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3549 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3554 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3559 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3564 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3569 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3574 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Dot :: T_Token+sem_Token_Dot =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3592 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Dot+                  {-# LINE 3597 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3602 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3607 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3612 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3617 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3622 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3627 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3632 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3637 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3642 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3647 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3652 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3657 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Comma :: T_Token+sem_Token_Comma =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3675 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Comma+                  {-# LINE 3680 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3685 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3690 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3695 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3700 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3705 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3710 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3715 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3720 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3725 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3730 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3735 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3740 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Hash :: T_Token+sem_Token_Hash =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3758 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Hash+                  {-# LINE 3763 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3768 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3773 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3778 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3783 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3788 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3793 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3798 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 3803 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 3808 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 3813 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 3818 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 3823 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Not :: T_Token+sem_Token_Not =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3841 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Not+                  {-# LINE 3846 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3851 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3856 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3861 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3866 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3871 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3876 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3881 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 185 "src/GLuaFixer/AG/LexLint.ag" #-}+                          (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . cUsed $ _lhsInotSyntax)+                          {-# LINE 3886 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _consistent ->+                   (case (({-# LINE 186 "src/GLuaFixer/AG/LexLint.ag" #-}+                           SyntaxUsed _consistent     False+                           {-# LINE 3891 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _notSyntax ->+                    (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _notSyntax+                            {-# LINE 3896 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnotSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsIorSyntax+                             {-# LINE 3901 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 3906 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 187 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 3911 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 187 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "not" "!"+                                {-# LINE 3917 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 187 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 3922 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 3927 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_CNot :: T_Token+sem_Token_CNot =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 3945 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  CNot+                  {-# LINE 3950 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 3955 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 3960 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 3965 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 3970 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 3975 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 3980 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 3985 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 191 "src/GLuaFixer/AG/LexLint.ag" #-}+                          (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . luaUsed $ _lhsInotSyntax)+                          {-# LINE 3990 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _consistent ->+                   (case (({-# LINE 192 "src/GLuaFixer/AG/LexLint.ag" #-}+                           SyntaxUsed False _consistent+                           {-# LINE 3995 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _notSyntax ->+                    (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _notSyntax+                            {-# LINE 4000 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnotSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsIorSyntax+                             {-# LINE 4005 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 4010 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 193 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 4015 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 193 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "!" "not"+                                {-# LINE 4021 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 193 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 4026 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 4031 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_And :: T_Token+sem_Token_And =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 197 "src/GLuaFixer/AG/LexLint.ag" #-}+                 (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . cUsed $ _lhsIandSyntax)+                 {-# LINE 4049 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _consistent ->+          (case (({-# LINE 198 "src/GLuaFixer/AG/LexLint.ag" #-}+                  SyntaxUsed _consistent     False+                  {-# LINE 4054 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _andSyntax ->+           (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _andSyntax+                   {-# LINE 4059 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOandSyntax ->+            (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                    And+                    {-# LINE 4064 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _copy ->+             (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _copy+                     {-# LINE 4069 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOcopy ->+              (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                      []+                      {-# LINE 4074 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOcustomWarnings ->+               (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsIindentation+                       {-# LINE 4079 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOindentation ->+                (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIlineCommentSyntax+                        {-# LINE 4084 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOlineCommentSyntax ->+                 (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsImultilineCommentSyntax+                         {-# LINE 4089 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOmultilineCommentSyntax ->+                  (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIneqSyntax+                          {-# LINE 4094 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOneqSyntax ->+                   (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                           customAdvanceToken _lhsInextTokenPos _copy+                           {-# LINE 4099 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOnextTokenPos ->+                    (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsInotSyntax+                            {-# LINE 4104 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnotSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsIorSyntax+                             {-# LINE 4109 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 4114 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 199 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 4119 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 199 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "and" "&&"+                                {-# LINE 4125 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 199 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 4130 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 4135 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_CAnd :: T_Token+sem_Token_CAnd =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 203 "src/GLuaFixer/AG/LexLint.ag" #-}+                 (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . luaUsed $ _lhsIandSyntax)+                 {-# LINE 4153 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _consistent ->+          (case (({-# LINE 204 "src/GLuaFixer/AG/LexLint.ag" #-}+                  SyntaxUsed False _consistent+                  {-# LINE 4158 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _andSyntax ->+           (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _andSyntax+                   {-# LINE 4163 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOandSyntax ->+            (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                    CAnd+                    {-# LINE 4168 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _copy ->+             (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _copy+                     {-# LINE 4173 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOcopy ->+              (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                      []+                      {-# LINE 4178 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOcustomWarnings ->+               (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsIindentation+                       {-# LINE 4183 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOindentation ->+                (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIlineCommentSyntax+                        {-# LINE 4188 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOlineCommentSyntax ->+                 (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsImultilineCommentSyntax+                         {-# LINE 4193 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOmultilineCommentSyntax ->+                  (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIneqSyntax+                          {-# LINE 4198 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOneqSyntax ->+                   (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                           customAdvanceToken _lhsInextTokenPos _copy+                           {-# LINE 4203 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOnextTokenPos ->+                    (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsInotSyntax+                            {-# LINE 4208 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOnotSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _lhsIorSyntax+                             {-# LINE 4213 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 4218 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 205 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 4223 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 205 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "&&" "and"+                                {-# LINE 4229 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 205 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 4234 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 4239 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Or :: T_Token+sem_Token_Or =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4257 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Or+                  {-# LINE 4262 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4267 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4272 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4277 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4282 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4287 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4292 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 4297 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 4302 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 209 "src/GLuaFixer/AG/LexLint.ag" #-}+                           (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . cUsed $ _lhsIorSyntax)+                           {-# LINE 4307 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _consistent ->+                    (case (({-# LINE 210 "src/GLuaFixer/AG/LexLint.ag" #-}+                            SyntaxUsed _consistent     False+                            {-# LINE 4312 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _orSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _orSyntax+                             {-# LINE 4317 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 4322 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 211 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 4327 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 211 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "or" "||"+                                {-# LINE 4333 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 211 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 4338 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 4343 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_COr :: T_Token+sem_Token_COr =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4361 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  COr+                  {-# LINE 4366 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4371 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4376 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4381 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4386 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4391 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4396 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 4401 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 4406 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 215 "src/GLuaFixer/AG/LexLint.ag" #-}+                           (not . lint_syntaxInconsistencies $ _lhsIconfig) || (not . luaUsed $ _lhsIorSyntax)+                           {-# LINE 4411 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _consistent ->+                    (case (({-# LINE 216 "src/GLuaFixer/AG/LexLint.ag" #-}+                            SyntaxUsed False _consistent+                            {-# LINE 4416 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _orSyntax ->+                     (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                             _orSyntax+                             {-# LINE 4421 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOorSyntax ->+                      (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                              _lhsIstrSyntax+                              {-# LINE 4426 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOstrSyntax ->+                       (case (({-# LINE 217 "src/GLuaFixer/AG/LexLint.ag" #-}+                               []+                               {-# LINE 4431 "src/GLuaFixer/AG/LexLint.hs" #-}+                               )) of+                        { _tokenWarnings_augmented_syn ->+                        (case (({-# LINE 217 "src/GLuaFixer/AG/LexLint.ag" #-}+                                if _consistent     then id else+                                   (:) $ SyntaxInconsistency "||" "or"+                                {-# LINE 4437 "src/GLuaFixer/AG/LexLint.hs" #-}+                                )) of+                         { _tokenWarnings_augmented_f1 ->+                         (case (({-# LINE 217 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 foldr ($) _tokenWarnings_augmented_syn [_tokenWarnings_augmented_f1]+                                 {-# LINE 4442 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _lhsOtokenWarnings ->+                          (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  []+                                  {-# LINE 4447 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _lhsOwarnings ->+                           ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Function :: T_Token+sem_Token_Function =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4465 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Function+                  {-# LINE 4470 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4475 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4480 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4485 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4490 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4495 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4500 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 4505 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 4510 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 4515 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 4520 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 4525 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 4530 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Local :: T_Token+sem_Token_Local =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4548 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Local+                  {-# LINE 4553 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4558 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4563 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4568 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4573 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4578 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4583 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 4588 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 4593 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 4598 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 4603 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 4608 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 4613 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_If :: T_Token+sem_Token_If =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4631 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  If+                  {-# LINE 4636 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4641 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4646 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4651 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4656 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4661 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4666 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 4671 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 4676 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 4681 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 4686 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 4691 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 4696 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Then :: T_Token+sem_Token_Then =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4714 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Then+                  {-# LINE 4719 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4724 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4729 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4734 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4739 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4744 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4749 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 4754 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 4759 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 4764 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 4769 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 4774 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 4779 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Elseif :: T_Token+sem_Token_Elseif =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4797 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Elseif+                  {-# LINE 4802 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4807 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4812 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4817 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4822 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4827 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4832 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 4837 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 4842 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 4847 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 4852 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 4857 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 4862 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Else :: T_Token+sem_Token_Else =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4880 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Else+                  {-# LINE 4885 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4890 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4895 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4900 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4905 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4910 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4915 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 4920 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 4925 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 4930 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 4935 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 4940 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 4945 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_For :: T_Token+sem_Token_For =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 4963 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  For+                  {-# LINE 4968 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 4973 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 4978 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 4983 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 4988 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 4993 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 4998 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5003 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5008 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5013 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5018 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5023 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5028 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_In :: T_Token+sem_Token_In =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5046 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  In+                  {-# LINE 5051 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5056 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5061 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5066 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5071 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5076 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5081 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5086 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5091 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5096 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5101 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5106 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5111 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Do :: T_Token+sem_Token_Do =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5129 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Do+                  {-# LINE 5134 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5139 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5144 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5149 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5154 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5159 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5164 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5169 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5174 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5179 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5184 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5189 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5194 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_While :: T_Token+sem_Token_While =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5212 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  While+                  {-# LINE 5217 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5222 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5227 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5232 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5237 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5242 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5247 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5252 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5257 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5262 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5267 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5272 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5277 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Until :: T_Token+sem_Token_Until =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5295 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Until+                  {-# LINE 5300 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5305 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5310 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5315 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5320 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5325 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5330 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5335 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5340 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5345 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5350 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5355 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5360 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Repeat :: T_Token+sem_Token_Repeat =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5378 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Repeat+                  {-# LINE 5383 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5388 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5393 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5398 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5403 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5408 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5413 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5418 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5423 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5428 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5433 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5438 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5443 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Continue :: T_Token+sem_Token_Continue =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5461 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Continue+                  {-# LINE 5466 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5471 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5476 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5481 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5486 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5491 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5496 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5501 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5506 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5511 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5516 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5521 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5526 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Break :: T_Token+sem_Token_Break =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5544 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Break+                  {-# LINE 5549 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5554 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5559 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5564 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5569 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5574 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5579 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5584 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5589 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5594 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5599 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5604 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5609 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Return :: T_Token+sem_Token_Return =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5627 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Return+                  {-# LINE 5632 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5637 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5642 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5647 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5652 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5657 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5662 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5667 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5672 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5677 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5682 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5687 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5692 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_End :: T_Token+sem_Token_End =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5710 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  End+                  {-# LINE 5715 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5720 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5725 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5730 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5735 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5740 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5745 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5750 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5755 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5760 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5765 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5770 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5775 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_LRound :: T_Token+sem_Token_LRound =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5793 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  LRound+                  {-# LINE 5798 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5803 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5808 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5813 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5818 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5823 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5828 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5833 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5838 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5843 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5848 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5853 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5858 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_RRound :: T_Token+sem_Token_RRound =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5876 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  RRound+                  {-# LINE 5881 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5886 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5891 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5896 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5901 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5906 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5911 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5916 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 5921 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 5926 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 5931 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 5936 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 5941 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_LCurly :: T_Token+sem_Token_LCurly =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 5959 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  LCurly+                  {-# LINE 5964 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 5969 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 5974 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 5979 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 5984 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 5989 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 5994 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 5999 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 6004 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 6009 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 6014 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 6019 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 6024 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_RCurly :: T_Token+sem_Token_RCurly =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 6042 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  RCurly+                  {-# LINE 6047 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 6052 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 6057 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 6062 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 6067 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 6072 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 6077 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 6082 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 6087 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 6092 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 6097 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 6102 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 6107 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_LSquare :: T_Token+sem_Token_LSquare =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 6125 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  LSquare+                  {-# LINE 6130 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 6135 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 6140 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 6145 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 6150 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 6155 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 6160 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 6165 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 6170 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 6175 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 6180 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 6185 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 6190 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_RSquare :: T_Token+sem_Token_RSquare =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 6208 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  RSquare+                  {-# LINE 6213 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 6218 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 6223 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 6228 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 6233 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 6238 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 6243 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 6248 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 6253 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 6258 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 6263 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 6268 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 6273 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Label :: String ->+                   T_Token+sem_Token_Label lbl_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 6292 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Label lbl_+                  {-# LINE 6297 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 6302 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 6307 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 6312 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 6317 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 6322 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 6327 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 233 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceStr _lhsInextTokenPos (showString "::" . showString lbl_ . showString "::" $ "")+                         {-# LINE 6332 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 6337 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 6342 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 6347 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 6352 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 6357 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_Token_Identifier :: String ->+                        T_Token+sem_Token_Identifier ident_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 6376 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  Identifier ident_+                  {-# LINE 6381 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 6386 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 96 "src/GLuaFixer/AG/LexLint.ag" #-}+                    []+                    {-# LINE 6391 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOcustomWarnings ->+             (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIindentation+                     {-# LINE 6396 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOindentation ->+              (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsIlineCommentSyntax+                      {-# LINE 6401 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOlineCommentSyntax ->+               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsImultilineCommentSyntax+                       {-# LINE 6406 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOmultilineCommentSyntax ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 6411 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOneqSyntax ->+                 (case (({-# LINE 167 "src/GLuaFixer/AG/LexLint.ag" #-}+                         customAdvanceToken _lhsInextTokenPos _copy+                         {-# LINE 6416 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnextTokenPos ->+                  (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsInotSyntax+                          {-# LINE 6421 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOnotSyntax ->+                   (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIorSyntax+                           {-# LINE 6426 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOorSyntax ->+                    (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                            _lhsIstrSyntax+                            {-# LINE 6431 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOstrSyntax ->+                     (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 6436 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOtokenWarnings ->+                      (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                              []+                              {-# LINE 6441 "src/GLuaFixer/AG/LexLint.hs" #-}+                              )) of+                       { _lhsOwarnings ->+                       ( _lhsOandSyntax,_lhsOcopy,_lhsOcustomWarnings,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+-- TokenList ---------------------------------------------------+-- cata+sem_TokenList :: TokenList ->+                 T_TokenList+sem_TokenList list =+    (Prelude.foldr sem_TokenList_Cons sem_TokenList_Nil (Prelude.map sem_Token list))+-- semantic domain+type T_TokenList = SyntaxUsed ->+                   LintSettings ->+                   SyntaxUsed ->+                   SyntaxUsed ->+                   SyntaxUsed ->+                   SyntaxUsed ->+                   LineColPos ->+                   SyntaxUsed ->+                   SyntaxUsed ->+                   SyntaxUsed ->+                   ( SyntaxUsed,TokenList,SyntaxUsed,SyntaxUsed,SyntaxUsed,SyntaxUsed,LineColPos,SyntaxUsed,SyntaxUsed,SyntaxUsed,([Issue]),([FilePath -> LintMessage]))+data Inh_TokenList = Inh_TokenList {andSyntax_Inh_TokenList :: SyntaxUsed,config_Inh_TokenList :: LintSettings,indentation_Inh_TokenList :: SyntaxUsed,lineCommentSyntax_Inh_TokenList :: SyntaxUsed,multilineCommentSyntax_Inh_TokenList :: SyntaxUsed,neqSyntax_Inh_TokenList :: SyntaxUsed,nextTokenPos_Inh_TokenList :: LineColPos,notSyntax_Inh_TokenList :: SyntaxUsed,orSyntax_Inh_TokenList :: SyntaxUsed,strSyntax_Inh_TokenList :: SyntaxUsed}+data Syn_TokenList = Syn_TokenList {andSyntax_Syn_TokenList :: SyntaxUsed,copy_Syn_TokenList :: TokenList,indentation_Syn_TokenList :: SyntaxUsed,lineCommentSyntax_Syn_TokenList :: SyntaxUsed,multilineCommentSyntax_Syn_TokenList :: SyntaxUsed,neqSyntax_Syn_TokenList :: SyntaxUsed,nextTokenPos_Syn_TokenList :: LineColPos,notSyntax_Syn_TokenList :: SyntaxUsed,orSyntax_Syn_TokenList :: SyntaxUsed,strSyntax_Syn_TokenList :: SyntaxUsed,tokenWarnings_Syn_TokenList :: ([Issue]),warnings_Syn_TokenList :: ([FilePath -> LintMessage])}+wrap_TokenList :: T_TokenList ->+                  Inh_TokenList ->+                  Syn_TokenList+wrap_TokenList sem (Inh_TokenList _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax) =+    (let ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) = sem _lhsIandSyntax _lhsIconfig _lhsIindentation _lhsIlineCommentSyntax _lhsImultilineCommentSyntax _lhsIneqSyntax _lhsInextTokenPos _lhsInotSyntax _lhsIorSyntax _lhsIstrSyntax+     in  (Syn_TokenList _lhsOandSyntax _lhsOcopy _lhsOindentation _lhsOlineCommentSyntax _lhsOmultilineCommentSyntax _lhsOneqSyntax _lhsOnextTokenPos _lhsOnotSyntax _lhsOorSyntax _lhsOstrSyntax _lhsOtokenWarnings _lhsOwarnings))+sem_TokenList_Cons :: T_Token ->+                      T_TokenList ->+                      T_TokenList+sem_TokenList_Cons hd_ tl_ =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 77 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIconfig+                 {-# LINE 6487 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _tlOconfig ->+          (case (({-# LINE 77 "src/GLuaFixer/AG/LexLint.ag" #-}+                  _lhsIconfig+                  {-# LINE 6492 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _hdOconfig ->+           (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _lhsIandSyntax+                   {-# LINE 6497 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _hdOandSyntax ->+            (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                    _lhsIstrSyntax+                    {-# LINE 6502 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _hdOstrSyntax ->+             (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIorSyntax+                     {-# LINE 6507 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _hdOorSyntax ->+              (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsInotSyntax+                      {-# LINE 6512 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _hdOnotSyntax ->+               (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsInextTokenPos+                       {-# LINE 6517 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _hdOnextTokenPos ->+                (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsIneqSyntax+                        {-# LINE 6522 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _hdOneqSyntax ->+                 (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsImultilineCommentSyntax+                         {-# LINE 6527 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _hdOmultilineCommentSyntax ->+                  (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIlineCommentSyntax+                          {-# LINE 6532 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _hdOlineCommentSyntax ->+                   (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIindentation+                           {-# LINE 6537 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _hdOindentation ->+                    (case (hd_ _hdOandSyntax _hdOconfig _hdOindentation _hdOlineCommentSyntax _hdOmultilineCommentSyntax _hdOneqSyntax _hdOnextTokenPos _hdOnotSyntax _hdOorSyntax _hdOstrSyntax) of+                     { ( _hdIandSyntax,_hdIcopy,_hdIcustomWarnings,_hdIindentation,_hdIlineCommentSyntax,_hdImultilineCommentSyntax,_hdIneqSyntax,_hdInextTokenPos,_hdInotSyntax,_hdIorSyntax,_hdIstrSyntax,_hdItokenWarnings,_hdIwarnings) ->+                         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                                 _hdIandSyntax+                                 {-# LINE 6544 "src/GLuaFixer/AG/LexLint.hs" #-}+                                 )) of+                          { _tlOandSyntax ->+                          (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                                  _hdIstrSyntax+                                  {-# LINE 6549 "src/GLuaFixer/AG/LexLint.hs" #-}+                                  )) of+                           { _tlOstrSyntax ->+                           (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                                   _hdIorSyntax+                                   {-# LINE 6554 "src/GLuaFixer/AG/LexLint.hs" #-}+                                   )) of+                            { _tlOorSyntax ->+                            (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                                    _hdInotSyntax+                                    {-# LINE 6559 "src/GLuaFixer/AG/LexLint.hs" #-}+                                    )) of+                             { _tlOnotSyntax ->+                             (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                                     _hdInextTokenPos+                                     {-# LINE 6564 "src/GLuaFixer/AG/LexLint.hs" #-}+                                     )) of+                              { _tlOnextTokenPos ->+                              (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                                      _hdIneqSyntax+                                      {-# LINE 6569 "src/GLuaFixer/AG/LexLint.hs" #-}+                                      )) of+                               { _tlOneqSyntax ->+                               (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                                       _hdImultilineCommentSyntax+                                       {-# LINE 6574 "src/GLuaFixer/AG/LexLint.hs" #-}+                                       )) of+                                { _tlOmultilineCommentSyntax ->+                                (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                                        _hdIlineCommentSyntax+                                        {-# LINE 6579 "src/GLuaFixer/AG/LexLint.hs" #-}+                                        )) of+                                 { _tlOlineCommentSyntax ->+                                 (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                                         _hdIindentation+                                         {-# LINE 6584 "src/GLuaFixer/AG/LexLint.hs" #-}+                                         )) of+                                  { _tlOindentation ->+                                  (case (tl_ _tlOandSyntax _tlOconfig _tlOindentation _tlOlineCommentSyntax _tlOmultilineCommentSyntax _tlOneqSyntax _tlOnextTokenPos _tlOnotSyntax _tlOorSyntax _tlOstrSyntax) of+                                   { ( _tlIandSyntax,_tlIcopy,_tlIindentation,_tlIlineCommentSyntax,_tlImultilineCommentSyntax,_tlIneqSyntax,_tlInextTokenPos,_tlInotSyntax,_tlIorSyntax,_tlIstrSyntax,_tlItokenWarnings,_tlIwarnings) ->+                                       (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                                               _tlIandSyntax+                                               {-# LINE 6591 "src/GLuaFixer/AG/LexLint.hs" #-}+                                               )) of+                                        { _lhsOandSyntax ->+                                        (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                (:) _hdIcopy _tlIcopy+                                                {-# LINE 6596 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                )) of+                                         { _copy ->+                                         (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                 _copy+                                                 {-# LINE 6601 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                 )) of+                                          { _lhsOcopy ->+                                          (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                  _tlIindentation+                                                  {-# LINE 6606 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                  )) of+                                           { _lhsOindentation ->+                                           (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                   _tlIlineCommentSyntax+                                                   {-# LINE 6611 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                   )) of+                                            { _lhsOlineCommentSyntax ->+                                            (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                    _tlImultilineCommentSyntax+                                                    {-# LINE 6616 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                    )) of+                                             { _lhsOmultilineCommentSyntax ->+                                             (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                     _tlIneqSyntax+                                                     {-# LINE 6621 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                     )) of+                                              { _lhsOneqSyntax ->+                                              (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                      _tlInextTokenPos+                                                      {-# LINE 6626 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                      )) of+                                               { _lhsOnextTokenPos ->+                                               (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                       _tlInotSyntax+                                                       {-# LINE 6631 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                       )) of+                                                { _lhsOnotSyntax ->+                                                (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                        _tlIorSyntax+                                                        {-# LINE 6636 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                        )) of+                                                 { _lhsOorSyntax ->+                                                 (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                         _tlIstrSyntax+                                                         {-# LINE 6641 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                         )) of+                                                  { _lhsOstrSyntax ->+                                                  (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                          _hdItokenWarnings ++ _tlItokenWarnings+                                                          {-# LINE 6646 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                          )) of+                                                   { _lhsOtokenWarnings ->+                                                   (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                                                           _hdIwarnings ++ _tlIwarnings+                                                           {-# LINE 6651 "src/GLuaFixer/AG/LexLint.hs" #-}+                                                           )) of+                                                    { _lhsOwarnings ->+                                                    ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))+sem_TokenList_Nil :: T_TokenList+sem_TokenList_Nil =+    (\ _lhsIandSyntax+       _lhsIconfig+       _lhsIindentation+       _lhsIlineCommentSyntax+       _lhsImultilineCommentSyntax+       _lhsIneqSyntax+       _lhsInextTokenPos+       _lhsInotSyntax+       _lhsIorSyntax+       _lhsIstrSyntax ->+         (case (({-# LINE 84 "src/GLuaFixer/AG/LexLint.ag" #-}+                 _lhsIandSyntax+                 {-# LINE 6669 "src/GLuaFixer/AG/LexLint.hs" #-}+                 )) of+          { _lhsOandSyntax ->+          (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                  []+                  {-# LINE 6674 "src/GLuaFixer/AG/LexLint.hs" #-}+                  )) of+           { _copy ->+           (case (({-# LINE 76 "src/GLuaFixer/AG/LexLint.ag" #-}+                   _copy+                   {-# LINE 6679 "src/GLuaFixer/AG/LexLint.hs" #-}+                   )) of+            { _lhsOcopy ->+            (case (({-# LINE 88 "src/GLuaFixer/AG/LexLint.ag" #-}+                    _lhsIindentation+                    {-# LINE 6684 "src/GLuaFixer/AG/LexLint.hs" #-}+                    )) of+             { _lhsOindentation ->+             (case (({-# LINE 81 "src/GLuaFixer/AG/LexLint.ag" #-}+                     _lhsIlineCommentSyntax+                     {-# LINE 6689 "src/GLuaFixer/AG/LexLint.hs" #-}+                     )) of+              { _lhsOlineCommentSyntax ->+              (case (({-# LINE 82 "src/GLuaFixer/AG/LexLint.ag" #-}+                      _lhsImultilineCommentSyntax+                      {-# LINE 6694 "src/GLuaFixer/AG/LexLint.hs" #-}+                      )) of+               { _lhsOmultilineCommentSyntax ->+               (case (({-# LINE 86 "src/GLuaFixer/AG/LexLint.ag" #-}+                       _lhsIneqSyntax+                       {-# LINE 6699 "src/GLuaFixer/AG/LexLint.hs" #-}+                       )) of+                { _lhsOneqSyntax ->+                (case (({-# LINE 90 "src/GLuaFixer/AG/LexLint.ag" #-}+                        _lhsInextTokenPos+                        {-# LINE 6704 "src/GLuaFixer/AG/LexLint.hs" #-}+                        )) of+                 { _lhsOnextTokenPos ->+                 (case (({-# LINE 83 "src/GLuaFixer/AG/LexLint.ag" #-}+                         _lhsInotSyntax+                         {-# LINE 6709 "src/GLuaFixer/AG/LexLint.hs" #-}+                         )) of+                  { _lhsOnotSyntax ->+                  (case (({-# LINE 85 "src/GLuaFixer/AG/LexLint.ag" #-}+                          _lhsIorSyntax+                          {-# LINE 6714 "src/GLuaFixer/AG/LexLint.hs" #-}+                          )) of+                   { _lhsOorSyntax ->+                   (case (({-# LINE 87 "src/GLuaFixer/AG/LexLint.ag" #-}+                           _lhsIstrSyntax+                           {-# LINE 6719 "src/GLuaFixer/AG/LexLint.hs" #-}+                           )) of+                    { _lhsOstrSyntax ->+                    (case (({-# LINE 93 "src/GLuaFixer/AG/LexLint.ag" #-}+                            []+                            {-# LINE 6724 "src/GLuaFixer/AG/LexLint.hs" #-}+                            )) of+                     { _lhsOtokenWarnings ->+                     (case (({-# LINE 79 "src/GLuaFixer/AG/LexLint.ag" #-}+                             []+                             {-# LINE 6729 "src/GLuaFixer/AG/LexLint.hs" #-}+                             )) of+                      { _lhsOwarnings ->+                      ( _lhsOandSyntax,_lhsOcopy,_lhsOindentation,_lhsOlineCommentSyntax,_lhsOmultilineCommentSyntax,_lhsOneqSyntax,_lhsOnextTokenPos,_lhsOnotSyntax,_lhsOorSyntax,_lhsOstrSyntax,_lhsOtokenWarnings,_lhsOwarnings) }) }) }) }) }) }) }) }) }) }) }) }) }))
+ src/GLuaFixer/BadSequenceFinder.hs view
@@ -0,0 +1,464 @@+{-# LANGUAGE LambdaCase #-}+module GLuaFixer.BadSequenceFinder (sequenceWarnings, checkFromString) where+++import GLua.AG.Token+import GLua.PSParser+import GLuaFixer.LintMessage+import GLuaFixer.LintSettings+import Text.Parsec+import qualified GLua.PSLexer as PSL++-- | Satisfy for normal tokens+pTSatisfy :: (Token -> Bool) -> AParser MToken+pTSatisfy f = pMSatisfy f'+ where+    f' :: MToken -> Bool+    f' (MToken _ t) = f t++-- | Parse an identifier+ident :: String -> AParser MToken+ident s = pMSatisfy isIdent+ where+    isIdent :: MToken -> Bool+    isIdent (MToken _ (Identifier s')) = s == s'+    isIdent _ = False++-- | Parse any kind of whitespace+whitespace :: AParser MToken+whitespace = pTSatisfy isWhitespace++-- | Whether a token is whitespace+isWhitespace :: Token -> Bool+isWhitespace (Whitespace _) = True+isWhitespace _ = False++-- | Whether a token consists of spaces+isSpaces :: Token -> Bool+isSpaces (Whitespace str) = all (== ' ') str+isSpaces _ = False++-- | Parse anything that isn't whitespace+notWhitespace :: AParser MToken+notWhitespace = pMSatisfy isNotWhitespace+ where+    isNotWhitespace :: MToken -> Bool+    isNotWhitespace (MToken _ (Whitespace _)) = False+    isNotWhitespace _ = True++-- | Warnings for deprecated library functions+libraryWarnings :: String -> AParser String -> AParser String+libraryWarnings s p = do+    ident s+    pMTok Dot++    p++-- | Warnings for the ai library+aiWarnings :: AParser String+aiWarnings = libraryWarnings "ai" $+    "The function is broken" <$ ident "GetScheduleID" <|>+    "The function is broken" <$ ident "GetTaskID"++-- | Warnings for the math library+mathWarnings :: AParser String+mathWarnings = libraryWarnings "math" $+    "Use math.Distance instead" <$ ident "Dist" <|>+    "Use math.fmod instead" <$ ident "mod"+++-- | Warnings for the spawnmenu library+spawnmenuWarnings :: AParser String+spawnmenuWarnings = libraryWarnings "spawnmenu" $+    "Use spawnmenu.SaveToTextFiles instead" <$ ident "DoSaveToTextFiles" <|>+    "Use spawnmenu.PopulateFromTextFiles instead" <$ ident "PopulateFromEngineTextFiles" <|>+    "The function is broken" <$ ident "SwitchToolTab"++-- | Warnings for the string library+stringWarnings :: AParser String+stringWarnings = libraryWarnings "string" $+    "Use either string.sub(str, index, index) or str[index]" <$ ident "GetChar" <|>+    "Use string.gmatch instead" <$ ident "gfind"++-- | Warnings for the surface library+surfaceWarnings :: AParser String+surfaceWarnings = libraryWarnings "surface" $+    "Use ScrH instead" <$ ident "ScreenHeight" <|>+    "Use ScrW instead" <$ ident "ScreenWidth"++-- | Warnings for the table library+tableWarnings :: AParser String+tableWarnings = libraryWarnings "table" $+    "Use ipairs or something instead" <$ (+        ident "FindNext" <|>+        ident "FindPrev" <|>+        ident "foreach"  <|>+        ident "ForEach"  <|>+        ident "foreachi"+    ) <|>+    "Use next instead" <$ (+        ident "GetFirstKey" <|>+        ident "GetFirstValue"+    ) <|>+    "Use #tbl instead"      <$ ident "GetLastKey"   <|>+    "Use tbl[#tbl] instead" <$ ident "GetLastValue" <|>+    "Use #tbl instead"      <$ ident "getn"+++-- | Warnings for the timer library+timerWarnings :: AParser String+timerWarnings = libraryWarnings "timer" $+    "The function is broken" <$ ident "Check" <|>+    "Use timer.Remove instead" <$ ident "Destroy"++-- | Warnings for the umsg library+umsgWarnings :: AParser String+umsgWarnings = libraryWarnings "umsg" $+    "Use net messages." <$ ident "Start"++-- | Warnings for the util library+utilWarnings :: AParser String+utilWarnings = libraryWarnings "util" $+    "Use tobool, without the util bit" <$ ident "tobool" <|>+    "The function is broken" <$ ident "TraceEntityHull"++-- | Warnings for things to do with self+selfWarnings :: AParser String+selfWarnings = libraryWarnings "self" $+    "Use self:GetOwner() instead" <$ ident "Owner"++-- | Warnings for meta functions+metaFuncWarnings :: AParser String+metaFuncWarnings = do+    pMTok Colon++    -- CLuaLocomotion functions+    "Use :IsUsingLadder instead"                                     <$ ident "IsAscendingOrDescendingLadder"       <|>++      -- Panel functions+      "Use :GetPaintBackground instead"                                <$ ident "GetDrawBackground"                   <|>+      "Use :SetPaintBackground instead"                                <$ ident "SetDrawBackground"                   <|>+      "The function is broken"                                         <$ ident "AddText"                             <|>+      "Only used by deprecated Derma controls"                         <$ ident "PostMessage"                         <|>+      "Only used in deprecated Derma controls"                         <$ ident "SetActionFunction"                   <|>+      "Use :SetKeyboardInputEnabled instead"                           <$ ident "SetKeyBoardInputEnabled"             <|>+      "The function is broken"                                         <$ ident "SetPaintFunction"                    <|>+      "Use :SetTooltip instead, notice the lowercase fucking t"        <$ ident "SetToolTip"                          <|>+      "use :SetTooltipPanel instead, notice the lowercase fucking t"   <$ ident "SetToolTipPanel"                     <|>+      "Use :IsValid instead"                                           <$ ident "Valid"                               <|>++      -- Entity functions+      "Use :GetHitBoxBone instead, note the capital fucking B"         <$ ident "GetHitboxBone"                       <|>+      "Use :GetNWAngle instead"                                        <$ ident "GetNetworkedAngle"                   <|>+      "Use :GetNWBool instead"                                         <$ ident "GetNetworkedBool"                    <|>+      "Use :GetNWEntity instead"                                       <$ ident "GetNetworkedEntity"                  <|>+      "Use :GetNWFloat instead"                                        <$ ident "GetNetworkedFloat"                   <|>+      "Use :GetNWInt instead"                                          <$ ident "GetNetworkedInt"                     <|>+      "Use :GetNWString instead"                                       <$ ident "GetNetworkedString"                  <|>+      "Use :GetNWVarProxy instead"                                     <$ ident "GetNetworkedVarProxy"                <|>+      "Use :GetNWVarTable instead"                                     <$ ident "GetNetworkedVarTable"                <|>+      "Use :GetNWVector instead"                                       <$ ident "GetNetworkedVector"                  <|>+      "The function is broken"                                         <$ ident "GetWorkshopID"                       <|>+      "Use :SetNWAngle instead"                                        <$ ident "SetNetworkedAngle"                   <|>+      "Use :SetNWBool instead"                                         <$ ident "SetNetworkedBool"                    <|>+      "Use :SetNWEntity instead"                                       <$ ident "SetNetworkedEntity"                  <|>+      "Use :SetNWFloat instead"                                        <$ ident "SetNetworkedFloat"                   <|>+      "Use :SetNWInt instead"                                          <$ ident "SetNetworkedInt"                     <|>+      "Use :SetNWString instead"                                       <$ ident "SetNetworkedString"                  <|>+      "Use :SetNWVarProxy instead"                                     <$ ident "SetNetworkedVarProxy"                <|>+      "Use :SetNWVector instead"                                       <$ ident "SetNetworkedVector"                  <|>++      -- Player functions+      "Use :GetViewPunchAngles instead"                                <$ ident "GetPunchAngle"                       <|>++      -- Material functions+      "The function is broken"                                         <$ ident "SetShader"                           <|>++      -- Vector functions+      "Use :Dot instead"                                               <$ ident "DotProduct"+++-- | Parser for all deprecated sequences of tokens+deprecatedSequence :: LintSettings -> AParser Issue+deprecatedSequence opts = if not (lint_deprecated opts) then parserZero else Deprecated <$> (++    -- Deprecated meta functions+    try metaFuncWarnings++    -- Library functions+    <|>try aiWarnings+    <|>try mathWarnings+    <|>try spawnmenuWarnings+    <|>try stringWarnings+    <|>try surfaceWarnings+    <|>try tableWarnings+    <|>try timerWarnings+    <|>try umsgWarnings+    <|>try utilWarnings+    <|>try selfWarnings++    -- Global functions+    <|> "Use collectgarbage(\"count\") instead"+        <$ ident "gcinfo"+    <|> "Use ConVar objects instead"+        <$ ident "GetConVarNumber"+    <|> "Use ConVar objects instead"+        <$ ident "GetConVarString"+    <|> "Use AddCSLuaFile in the file itself instead"+        <$ ident "IncludeCS"+    <|> "Use ScreenScale instead"+        <$ ident "SScale"+    <|> "Use IsUselessModel instead"+        <$ ident "UTIL_IsUselessModel"+    <|> "Use IsValid instead"+        <$ ident "ValidPanel"+    <|> "Use net messages."+        <$ ident "SendUserMessage"+    )++-- | Parser for all beginner mistakes+beginnerMistakeSequence :: LintSettings -> AParser Issue+beginnerMistakeSequence opts = if not (lint_beginnerMistakes opts) then parserZero else BeginnerMistake <$>+    (try ("There's little fucking reason to use ';' in the first place, don't use it twice in a row" <$ pMTok Semicolon <* pMTok Semicolon) <|>+    try ("The server already knows who sent the net message, use the first parameter of net.Receive" <$ do+        ident "net"+        pMTok Dot+        ident "WriteEntity"+        pMTok LRound+        optional whitespace+        ident "LocalPlayer"+        optional whitespace+        pMTok LRound+        optional whitespace+        pMTok RRound+        ) <|>+    try ("Jesus christ fuck off already" <$ do+        pMTok While+        whitespace+        pMTok TTrue+        whitespace+        pMTok Do+        whitespace+        pMTok End+        )+    )++whiteSpaceStyleSequence :: LintSettings -> AParser Issue+whiteSpaceStyleSequence opts = if not (lint_whitespaceStyle opts) then parserZero else WhitespaceStyle <$> (+    try ("Please put some whitespace after 'if'" <$ pMTok If <* notFollowedBy whitespace)            <|>+    try ("Please put some whitespace after 'elseif'" <$ pMTok Elseif <* notFollowedBy whitespace)    <|>+    try ("Please put some whitespace after 'while'" <$ pMTok While <* notFollowedBy whitespace)      <|>+    try ("Please put some whitespace after 'until'" <$ pMTok Until <* notFollowedBy whitespace)      <|>++    try ("Please put some whitespace after ')'" <$ do+        pMTok RRound+        pTSatisfy (\t -> not (isWhitespace t) && t `notElem` [Colon, RRound, LRound, LSquare, RSquare, LCurly, RCurly, Comma, Dot, Semicolon])+        ) <|>+    try ("Please put some whitespace before the operator" <$ do+        notWhitespace+        choice [pMTok Plus, pMTok Multiply, pMTok Divide, pMTok Modulus, pMTok TEq, pMTok TNEq, pMTok TCNEq, pMTok TLEQ, pMTok TGEQ, pMTok TLT, pMTok TGT, pMTok Equals, pMTok Concatenate, pMTok And, pMTok CAnd, pMTok Or, pMTok COr]+        ) <|>+    try ("Please put some whitespace after the operator" <$ do+        choice [pMTok Plus, pMTok Multiply, pMTok Divide, pMTok Modulus, pMTok TEq, pMTok TNEq, pMTok TCNEq, pMTok TLEQ, pMTok TGEQ, pMTok TLT, pMTok TGT, pMTok Equals, pMTok Concatenate, pMTok And, pMTok CAnd, pMTok Or, pMTok COr]+        notWhitespace+        )+    )++-- | Matches any token but the given one+pNotTToken :: Token -> AParser MToken+pNotTToken t = pTSatisfy (t /=)++-- | Warn about adding or removing spaces after an opening parenthesis. What it actually checks for+-- and wants the user to do depends on the prettyprint_spaceBetweenParens and+-- prettyprint_spaceEmptyParens settings+spaceAfterParenthesis :: LintSettings -> AParser Issue+spaceAfterParenthesis settings+    | not (lint_spaceBetweenParens settings) = parserZero+    | otherwise =+        case (prettyprint_spaceBetweenParens settings, prettyprint_spaceEmptyParens settings) of+          (True, True) ->+            SpaceAfterParenthesis AddSpace <$ try (pMTok LRound >> notWhitespace)+          (False, False) ->+            SpaceAfterParenthesis RemoveSpace <$ try (pMTok LRound >> pTSatisfy isSpaces)+          (True, False) ->+            SpaceAfterParenthesis AddSpace <$ try (pMTok LRound >> notWhitespaceAndNotClose) <|>+            SpaceAfterParenthesis RemoveSpace <$ try (pMTok LRound >> pTSatisfy isSpaces >> pMTok RRound)+          (False, True) ->+            SpaceAfterParenthesis RemoveSpace <$ try (pMTok LRound >> pTSatisfy isSpaces >> pNotTToken RRound) <|>+            SpaceAfterParenthesis AddSpace <$ try (pMTok LRound >> pMTok RRound)+  where+    notWhitespaceAndNotClose :: AParser MToken+    notWhitespaceAndNotClose = pTSatisfy $ \case+      RRound -> False+      Whitespace _ -> False+      _ -> True++-- | Warn about adding or removing spaces before a closing parenthesis+spaceBeforeParenthesis :: LintSettings -> AParser Issue+spaceBeforeParenthesis settings+    | not (lint_spaceBetweenParens settings) = parserZero+    | otherwise =+        case (prettyprint_spaceBetweenParens settings, prettyprint_spaceEmptyParens settings) of+          (True, True) ->+            SpaceBeforeParenthesis AddSpace <$ try (notWhitespace >> pMTok RRound)+          (False, False) ->+            SpaceBeforeParenthesis RemoveSpace <$ try (pTSatisfy isSpaces >> pMTok RRound)+          (True, False) ->+            SpaceBeforeParenthesis AddSpace <$ try (notWhitespaceAndNotOpen >> pMTok RRound)+          (False, True) ->+            SpaceBeforeParenthesis RemoveSpace <$ try (pNotTToken LRound >> pTSatisfy isSpaces >> pMTok RRound)+  where+    notWhitespaceAndNotOpen :: AParser MToken+    notWhitespaceAndNotOpen = pTSatisfy $ \case+      LRound -> False+      Whitespace _ -> False+      _ -> True++-- | Warn about adding or removing spaces after an opening brace (`}`). What it actually checks for+-- and wants the user to do depends on the prettyprint_spaceBetweenBraces and+-- prettyprint_spaceEmptyBraces settings+spaceAfterBraces :: LintSettings -> AParser Issue+spaceAfterBraces settings+    | not (lint_spaceBetweenBraces settings) = parserZero+    | otherwise =+        case (prettyprint_spaceBetweenBraces settings, prettyprint_spaceEmptyBraces settings) of+          (True, True) ->+            SpaceAfterBrace AddSpace <$ try (pMTok LCurly >> notWhitespace)+          (False, False) ->+            SpaceAfterBrace RemoveSpace <$ try (pMTok LCurly >> pTSatisfy isSpaces)+          (True, False) ->+            SpaceAfterBrace AddSpace <$ try (pMTok LCurly >> notWhitespaceAndNotClose) <|>+            SpaceAfterBrace RemoveSpace <$ try (pMTok LCurly >> pTSatisfy isSpaces >> pMTok RCurly)+          (False, True) ->+            SpaceAfterBrace RemoveSpace <$ try (pMTok LCurly >> pTSatisfy isSpaces >> pNotTToken RCurly) <|>+            SpaceAfterBrace AddSpace <$ try (pMTok LCurly >> pMTok RCurly)+  where+    notWhitespaceAndNotClose :: AParser MToken+    notWhitespaceAndNotClose = pTSatisfy $ \case+      RCurly -> False+      Whitespace _ -> False+      _ -> True++-- | Warn about adding or removing spaces before a closing brace (`}`)+spaceBeforeBraces :: LintSettings -> AParser Issue+spaceBeforeBraces settings+    | not (lint_spaceBetweenBraces settings) = parserZero+    | otherwise =+        case (prettyprint_spaceBetweenBraces  settings, prettyprint_spaceEmptyBraces settings) of+          (True, True) ->+            SpaceBeforeBrace AddSpace <$ try (notWhitespace >> pMTok RCurly)+          (False, False) ->+            SpaceBeforeBrace RemoveSpace <$ try (pTSatisfy isSpaces >> pMTok RCurly)+          (True, False) ->+            SpaceBeforeBrace AddSpace <$ try (notWhitespaceAndNotOpen >> pMTok RCurly)+          (False, True) ->+            SpaceBeforeBrace RemoveSpace <$ try (pNotTToken LCurly >> pTSatisfy isSpaces >> pMTok RCurly)+  where+    notWhitespaceAndNotOpen :: AParser MToken+    notWhitespaceAndNotOpen = pTSatisfy $ \case+      LCurly -> False+      Whitespace _ -> False+      _ -> True++-- | Warn about adding or removing spaces after an opening bracket (`[`). What it actually checks+-- for and wants the user to do depends on the prettyprint_spaceBetweenBracket+spaceAfterBrackets :: LintSettings -> AParser Issue+spaceAfterBrackets settings+    | not (lint_spaceBetweenBrackets settings) = parserZero+    | prettyprint_spaceBetweenBrackets settings =+      SpaceAfterBracket AddSpace <$ try (pMTok LSquare >> notWhitespace)+    | otherwise =+      SpaceAfterBracket RemoveSpace <$ try (pMTok LSquare >> pTSatisfy isSpaces)++-- | Warn about adding or removing spaces before a closing bracket (`]`)+spaceBeforeBrackets :: LintSettings -> AParser Issue+spaceBeforeBrackets settings+    | not (lint_spaceBetweenBrackets settings) = parserZero+    | prettyprint_spaceBetweenBrackets settings =+      SpaceBeforeBracket AddSpace <$ try (notWhitespace >> pMTok RSquare)+    | otherwise =+      SpaceBeforeBracket RemoveSpace <$ try (pTSatisfy isSpaces >> pMTok RSquare)++-- | Warn about adding or removing spaces after a comma+spaceAfterComma :: LintSettings -> AParser Issue+spaceAfterComma settings+    | not (lint_spaceAfterComma settings) = parserZero+    | prettyprint_spaceAfterComma settings =+      SpaceAfterComma AddSpace <$ try (pMTok Comma >> notWhitespace)+    | otherwise =+      SpaceAfterComma RemoveSpace <$ try (pMTok Comma >> pTSatisfy isSpaces)++-- | Warn about adding or removing spaces before a comma+spaceBeforeComma :: LintSettings -> AParser Issue+spaceBeforeComma settings+    | not (lint_spaceBeforeComma settings) = parserZero+    | prettyprint_spaceBeforeComma settings =+      SpaceBeforeComma AddSpace <$ try (notWhitespace >> pMTok Comma)+    | otherwise =+      SpaceBeforeComma RemoveSpace <$ try (pTSatisfy isSpaces >> pMTok Comma)++-- | Parser for all profanity+profanitySequence :: LintSettings -> AParser Issue+profanitySequence opts = if not (lint_profanity opts) then parserZero else Profanity <$ (+    ident "anus"                    <|>+    ident "bitch"                   <|>+    ident "cock"                    <|>+    ident "cocks"                   <|>+    ident "cunt"                    <|>+    ident "dick"                    <|>+    ident "dicks"                   <|>+    ident "fuck"                    <|>+    ident "fucking"                 <|>+    ident "goddamnit"               <|>+    ident "knob"                    <|>+    ident "knobs"                   <|>+    ident "motherfucker"            <|>+    ident "nipple"                  <|>+    ident "shit"+    )++-- | Parses for any bad sequence+badSequence :: LintSettings -> AParser Issue+badSequence opts =+    deprecatedSequence opts <|>+    profanitySequence opts <|>+    beginnerMistakeSequence opts <|>+    whiteSpaceStyleSequence opts <|>++    spaceAfterParenthesis opts <|>+    spaceBeforeParenthesis opts <|>++    spaceAfterBraces opts <|>+    spaceBeforeBraces opts <|>++    spaceAfterBrackets opts <|>+    spaceBeforeBrackets opts <|>++    spaceAfterComma opts <|>+    spaceBeforeComma opts++-- | Creates a warning for a certain sequence at any position+badSequenceWarning :: Region -> Issue -> [FilePath -> LintMessage] -> [FilePath -> LintMessage]+badSequenceWarning pos message = (:) (LintMessage LintWarning pos message)++-- | Searches for all the bad sequences+badSequenceParser :: LintSettings -> AParser [String -> LintMessage]+badSequenceParser opts =+    -- A bad sequence+    annotated badSequenceWarning (badSequence opts) <*> badSequenceParser opts <|>+    -- Continue searching+    anyToken *> badSequenceParser opts <|>+    -- end of input+    return []++-- | Returns all the warnings for a lexicon+sequenceWarnings :: LintSettings -> [MToken] -> [String -> LintMessage]+sequenceWarnings opts mts = case execAParser "source.lua" (badSequenceParser opts) mts of+    Left _ -> error "[Error] line 1, column 1: Sequence finding error! Report an issue!"+    Right warnings -> warnings++-- | Helper function: check from string+checkFromString :: AParser a -> String -> Either ParseError a+checkFromString p inp = do+    lexed <- PSL.execParseTokens inp+    execAParser "source.lua" p lexed
+ src/GLuaFixer/Interface.hs view
@@ -0,0 +1,71 @@+{-# LANGUAGE OverloadedRecordDot #-}++module GLuaFixer.Interface where++import GLua.AG.AST (AST)+import GLua.AG.PrettyPrint (prettyprintConf)+import GLua.AG.Token (MToken, Region)+import qualified GLua.Lexer as UUL+import GLua.LineLimitParser (LineLimit (..), execParseLineLimits)+import qualified GLua.PSLexer as PSL+import qualified GLua.PSParser as PSP+import qualified GLua.Parser as UUP+import GLuaFixer.AG.ASTLint (astWarnings)+import GLuaFixer.AG.LexLint (fixedLexPositions, lintWarnings)+import GLuaFixer.BadSequenceFinder (sequenceWarnings)+import GLuaFixer.LintMessage (Issue (..), LintMessage (..), Severity (..))+import GLuaFixer.LintSettings (LintSettings (..), lint2ppSetting)+import Text.Parsec.Error (errorPos)+import Text.ParserCombinators.UU.BasicInstances (Error, LineColPos)++-- | Run the linters that apply to the source code of a file+sourceLint :: LintSettings -> FilePath -> String -> [LintMessage]+sourceLint lintSettings filepath contents =+  execParseLineLimits filepath (LineLimit $ lint_maxLineLength lintSettings) contents++-- | Generate the lexicon of a source file, used as input for the parser+lex :: LintSettings -> FilePath -> String -> Either [LintMessage] [MToken]+lex lintSettings filepath contents =+  case PSL.execParseTokens contents of+    Left lexErr ->+      Left [LintMessage LintError (PSL.sp2Rg $ errorPos lexErr) (IssueParseError lexErr) filepath | lintSettings.lint_syntaxErrors]+    Right tokens -> Right $ fixedLexPositions tokens++-- | Use the (slower, but error-correcting) UU-parsinglib lexer to generate the lexicon+lexUU :: LintSettings -> String -> ([MToken], [Error LineColPos])+lexUU lintSettings contents = case UUL.execParseTokens contents of+  (tokens, errors) ->+    ( fixedLexPositions tokens+    , [err | lintSettings.lint_syntaxErrors, err <- errors]+    )++-- | Run the linting functions that inspect the lexicon+lexiconLint :: FilePath -> LintSettings -> [MToken] -> [LintMessage]+lexiconLint filepath lintSettings tokens =+  map ($ filepath) $+    lintWarnings lintSettings tokens ++ sequenceWarnings lintSettings tokens++-- | Parse a lexicon into an Abstract Syntax Tree+parse :: LintSettings -> FilePath -> [MToken] -> Either [LintMessage] AST+parse lintSettings filepath tokens =+  case PSP.parseGLua tokens of+    Left err ->+      -- Return syntax errors+      Left [LintMessage LintError (PSL.sp2Rg $ errorPos err) (IssueParseError err) filepath | lint_syntaxErrors lintSettings]+    Right ast -> Right ast++{- | Parse a lexicon into an Abstract Syntax Tree using the slower, but error-correcting+uu-parsinglib+-}+parseUU :: [MToken] -> (AST, [Error Region])+parseUU = UUP.parseGLua++-- | Run the linters that inspect the AST+astLint :: FilePath -> LintSettings -> AST -> [LintMessage]+astLint filepath lintSettings ast =+  map ($ filepath) $ astWarnings lintSettings ast++-- | Pretty print code to a string+prettyprint :: LintSettings -> AST -> String+prettyprint lintSettings ast =+  prettyprintConf (lint2ppSetting lintSettings) ast
+ src/GLuaFixer/LintMessage.hs view
@@ -0,0 +1,276 @@+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE LambdaCase #-}+module GLuaFixer.LintMessage where++import Control.Monad+import Data.Aeson+import Data.List (sortOn)+import Data.Maybe (isJust)+import System.Environment (lookupEnv)+import Text.Parsec (ParseError)+import Text.ParserCombinators.UU.BasicInstances hiding (msgs)++import GLua.AG.Token+import GLua.AG.PrettyPrint++-- | Output formats for logging+data LogFormat = StandardLogFormat | GithubLogFormat+data LogFormatChoice = AutoLogFormatChoice | LogFormatChoice !LogFormat++instance Show LogFormat where+  show StandardLogFormat = "standard"+  show GithubLogFormat = "github"++instance Show LogFormatChoice where+  show (LogFormatChoice choice) = show choice+  show AutoLogFormatChoice = "auto"++instance ToJSON LogFormat where+  toJSON StandardLogFormat = "standard"+  toJSON GithubLogFormat = "github"++instance ToJSON LogFormatChoice where+  toJSON (LogFormatChoice choice) = toJSON choice+  toJSON AutoLogFormatChoice = "auto"++instance FromJSON LogFormatChoice where+  parseJSON (String logFormat) = case logFormat of+    "standard" -> pure $ LogFormatChoice StandardLogFormat+    "github" -> pure $ LogFormatChoice GithubLogFormat+    "auto" -> pure AutoLogFormatChoice+    _ -> fail ( "Please use either \"auto\" \"standard\" or \"github\" but was " ++ show logFormat )+  parseJSON _ = mzero++data Severity = LintWarning | LintError+  deriving (Eq)++-- | With the Space(Before|After)(Parenthesis|Bracket|Brace), it depends on the pretty print+-- settings whether the space is desired or not. This encodes what we ask the user to do.+data RemoveOrAddSpace+  = RemoveSpace+  | AddSpace+  deriving (Eq)++-- | Representation of the different kinds of issues that can be raised. Many of the arguments are+-- 'String', because this data type is a rewrite of what was previously directly rendered Strings.+-- Many of these Strings can later be rewritten to their own types if necessary.+data Issue+  = IssueParseError ParseError++    -- From BadSequenceFinder+  | Deprecated !String -- ^ Reason+  | Profanity+  | BeginnerMistake !String -- ^ message+  | WhitespaceStyle !String -- ^ message+  | SpaceAfterParenthesis !RemoveOrAddSpace+  | SpaceBeforeParenthesis !RemoveOrAddSpace+  | SpaceAfterBracket !RemoveOrAddSpace+  | SpaceBeforeBracket !RemoveOrAddSpace+  | SpaceAfterBrace !RemoveOrAddSpace+  | SpaceBeforeBrace !RemoveOrAddSpace+  | SpaceAfterComma !RemoveOrAddSpace+  | SpaceBeforeComma !RemoveOrAddSpace++  -- Issues found in the lexicon (see LexLint.ag)+  | TrailingWhitespace+  | InconsistentTabsSpaces+  | SyntaxInconsistency+    !String -- ^ First encountered+    !String -- ^ Second encountered++  -- Line length limit (see LineLimitParser.hs)+  | LineTooLong++  -- Issues found in the AST (see ASTLint.ag)+  | VariableShadows+    !String -- ^ Name of the variable being shadowed+    !Region -- ^ Definition location of variable being shadowed+  | GotoAsIdentifier+  | InconsistentVariableNaming+  | ScopePyramids+  | UnusedVariable !String -- ^ Variable name+  | AvoidGoto+  | EmptyDoBlock+  | EmptyWhileLoop+  | EmptyRepeat+  | EmptyIf+  | DoubleIf+  | EmptyFor+  | EmptyElseIf+  | EmptyElse+  | SelfInNonMeta+  | SelfEntity+  | SelfWeapon+  | UnnecessaryParentheses+  | SillyNegation !String -- ^ Alternative to using the negation+  | DuplicateKeyInTable !Token -- ^ The key that is duplicated+  deriving Eq++-- | Represents lint messages+data LintMessage+  = LintMessage+    { lintmsg_severity :: !Severity+    , lintmsg_region   :: !Region+    , lintmsg_message  :: !Issue+    , lintmsg_file     :: !FilePath+    }+  deriving (Eq)++instance Show LintMessage where+    show = formatLintMessageDefault++issueDescription :: Issue -> String+issueDescription = \case+  IssueParseError parseError -> renderPSError parseError++  Deprecated reason -> "Deprecated: " ++ reason+  Profanity -> "Watch your profanity"+  BeginnerMistake msg -> msg+  WhitespaceStyle msg -> "Style: " ++ msg+  SpaceAfterParenthesis RemoveSpace -> "Style: Please remove the space after the parenthesis"+  SpaceAfterParenthesis AddSpace -> "Style: Please add a space after the parenthesis"+  SpaceBeforeParenthesis RemoveSpace -> "Style: Please remove the space before the parenthesis"+  SpaceBeforeParenthesis AddSpace -> "Style: Please add a space before the parenthesis"+  SpaceAfterBracket RemoveSpace -> "Style: Please remove the space after the bracket"+  SpaceAfterBracket AddSpace -> "Style: Please add a space after the bracket"+  SpaceBeforeBracket RemoveSpace -> "Style: Please remove the space before the bracket"+  SpaceBeforeBracket AddSpace -> "Style: Please add a space before the bracket"+  SpaceAfterBrace RemoveSpace -> "Style: Please remove the space after the brace"+  SpaceAfterBrace AddSpace -> "Style: Please add a space after the brace"+  SpaceBeforeBrace RemoveSpace -> "Style: Please remove the space before the brace"+  SpaceBeforeBrace AddSpace -> "Style: Please add a space before the brace"+  SpaceAfterComma RemoveSpace -> "Style: Please remove the space after the comma"+  SpaceAfterComma AddSpace -> "Style: Please add a space after the comma"+  SpaceBeforeComma RemoveSpace -> "Style: Please remove the space before the comma"+  SpaceBeforeComma AddSpace -> "Style: Please add a space before the comma"++  TrailingWhitespace -> "Trailing whitespace"+  InconsistentTabsSpaces -> "Inconsistent use of tabs and spaces for indentation"+  SyntaxInconsistency firstEncountered secondEncountered ->+    "Inconsistent use of '" ++ firstEncountered ++ "' and '" ++ secondEncountered ++ "'"++  LineTooLong -> "Style: Line too long"++  VariableShadows lbl (Region start _) ->+    "Variable '" ++ lbl ++ "' shadows existing binding, defined at " ++ renderPos start+  GotoAsIdentifier ->+    "Don't use 'goto' as an identifier, later versions of Lua will confuse it with the goto keyword."+  InconsistentVariableNaming ->+    "Inconsistent variable naming! There are variables that start with a lowercase letter, as well as ones that start with an uppercase letter. Please decide on one style."+  ScopePyramids ->+    "Are you Egyptian? What's with these fucking scope pyramids!?"+  UnusedVariable varName ->+    "Unused variable: " ++ varName+  AvoidGoto ->+    "Don't use labels and gotos unless you're jumping out of multiple loops."+  EmptyDoBlock -> "Empty do block"+  EmptyWhileLoop -> "Empty while loop"+  EmptyRepeat -> "Empty repeat statement"+  EmptyIf -> "Empty if statement"+  DoubleIf ->+    "Double if statement. Please combine the condition of this if statement with that of the outer if statement using `and`."+  EmptyFor -> "Empty for loop"+  EmptyElseIf -> "Empty elseif statement"+  EmptyElse -> "Empty else statement"+  SelfInNonMeta ->+    "Don't use self in a non-metafunction"+  SelfEntity ->+    "'self.Entity' is the same as just 'self' in SENTs"+  SelfWeapon ->+    "'self.Weapon' is the same as just 'self' in SWEPs"+  UnnecessaryParentheses -> "Unnecessary parentheses"+  SillyNegation alternative ->+    "Silly negation. Use '" ++ alternative ++ "'"+  DuplicateKeyInTable keyToken ->+    "Duplicate key in table: '" ++ show keyToken ++ "'."++-- | Shorthand title of an issue. Several issues may share the same title.+issueTitle :: Issue -> String+issueTitle = \case+  IssueParseError _ -> "Parse error"+  Deprecated _ -> "Deprecated"+  Profanity -> "Profanity"+  BeginnerMistake _ -> "Beginner mistake"+  WhitespaceStyle _ -> "Whitespace style"+  TrailingWhitespace -> "Trailing whitespace"+  SpaceAfterParenthesis _ -> "Space after parenthesis"+  SpaceBeforeParenthesis _ -> "Space before parenthesis"+  SpaceAfterBracket _ -> "Space after bracket"+  SpaceBeforeBracket _ -> "Space before bracket"+  SpaceAfterBrace _ -> "Space after brace"+  SpaceBeforeBrace _ -> "Space before brace"+  SpaceAfterComma _ -> "Space after comma"+  SpaceBeforeComma _ -> "Space before comma"+  InconsistentTabsSpaces -> "Syntax inconsistency"+  SyntaxInconsistency _ _ -> "Syntax inconsistency"+  LineTooLong -> "Line too long"+  VariableShadows _ _ -> "Shadowing"+  GotoAsIdentifier -> "Goto"+  InconsistentVariableNaming -> "Variable inconsistency"+  ScopePyramids -> "Scope depth"+  UnusedVariable _ -> "Unused variable"+  AvoidGoto -> "Goto"+  EmptyDoBlock -> "Empty block"+  EmptyWhileLoop -> "Empty block"+  EmptyRepeat -> "Empty block"+  EmptyIf -> "Empty block"+  DoubleIf -> "Double if-statement"+  EmptyFor -> "Empty block"+  EmptyElseIf -> "Empty block"+  EmptyElse -> "Empty block"+  SelfInNonMeta -> "Bad self"+  SelfEntity -> "Deprecated"+  SelfWeapon -> "Deprecated"+  UnnecessaryParentheses -> "Unnecessary parentheses"+  SillyNegation _ -> "Unnecessary negation"+  DuplicateKeyInTable _ -> "Duplicate key"+++logFormatChoiceToLogFormat :: LogFormatChoice -> IO LogFormat+logFormatChoiceToLogFormat = \case+  LogFormatChoice format -> pure format+  AutoLogFormatChoice -> do+    actionsExists <- isJust <$> lookupEnv "GITHUB_ACTIONS"+    workflowExists <- isJust <$> lookupEnv "GITHUB_WORKFLOW"+    if actionsExists && workflowExists+    then pure GithubLogFormat+    else pure StandardLogFormat+++formatLintMessage :: LogFormat -> LintMessage -> String+formatLintMessage StandardLogFormat lintMsg = formatLintMessageDefault lintMsg+formatLintMessage GithubLogFormat lintMsg = formatLintMessageGithub lintMsg++formatLintMessageDefault :: LintMessage -> String+formatLintMessageDefault (LintMessage severity region msg file) =+  let+    level = case severity of+      LintWarning -> "Warning"+      LintError -> "Error"+  in+    showString file .+    showString ": [" . showString level . showString "] " .+    showString (renderRegion region) . showString ": " .+    showString (issueDescription msg) $+    ""++formatLintMessageGithub :: LintMessage -> String+formatLintMessageGithub (LintMessage severity (Region (LineColPos line col _) (LineColPos endLine endCol _)) msg file) =+  let+    level = case severity of+      LintWarning -> "warning"+      LintError -> "error"+  in+    showString "::" . showString level .+    showString " file=" . showString file .+    showString ",line=" . shows (succ line) .+    showString ",col=" . shows (succ col) .+    showString ",endLine=" . shows (succ endLine) .+    showString ",endColumn=" . shows (succ endCol) .+    showString ",title=" . shows (issueTitle msg) .+    showString "::" . showString (issueDescription msg) $+    ""++-- | Sort lint messages on file and then region+sortLintMessages :: [LintMessage] -> [LintMessage]+sortLintMessages = sortOn (\(LintMessage _ rg _ f) -> (f, rg))
+ src/GLuaFixer/LintSettings.hs view
@@ -0,0 +1,264 @@+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE OverloadedStrings #-}+module GLuaFixer.LintSettings where++import Control.Applicative ((<|>))+import Data.Aeson+    ( FromJSON(parseJSON),+      ToJSON(toJSON),+      (.!=),+      (.:?),+      object,+      Value(Object),+      KeyValue((.=)) )+import Control.Monad ( MonadPlus(mzero) )+import Data.String (IsString)+import GLua.AG.PrettyPrint ( PrettyPrintConfig(..) )+import GLuaFixer.LintMessage+    ( LogFormatChoice(AutoLogFormatChoice) )++-- | Indentation used for pretty printing code+newtype Indentation = Indentation { unIndentation :: String }+  deriving IsString+  deriving newtype Show++-- | Whether a file is read from stdin or from files+data StdInOrFiles+  = UseStdIn+  | UseFiles [FilePath]+  deriving (Show)++-- | Convert a string to StdInOrFiles+parseStdInOrFiles :: String -> StdInOrFiles+parseStdInOrFiles "stdin" = UseStdIn+parseStdInOrFiles other = UseFiles [other]++data LintSettings =+    LintSettings+    { lint_maxScopeDepth :: !Int+    , lint_syntaxErrors :: !Bool+    , lint_syntaxInconsistencies :: !Bool+    , lint_deprecated :: !Bool+    , lint_trailingWhitespace :: !Bool+    , lint_whitespaceStyle :: !Bool+    , lint_beginnerMistakes :: !Bool+    , lint_emptyBlocks :: !Bool+    , lint_shadowing :: !Bool+    , lint_gotos :: !Bool+    , lint_goto_identifier :: !Bool+    , lint_doubleNegations :: !Bool+    , lint_redundantIfStatements :: !Bool+    , lint_redundantParentheses :: !Bool+    , lint_duplicateTableKeys :: !Bool+    , lint_profanity :: !Bool+    , lint_unusedVars :: !Bool+    , lint_unusedParameters :: !Bool+    , lint_unusedLoopVars :: !Bool+    , lint_inconsistentVariableStyle :: !Bool+    , lint_spaceBetweenParens :: !Bool+    , lint_spaceBetweenBrackets :: !Bool+    , lint_spaceBetweenBraces :: !Bool+    , lint_spaceBeforeComma :: !Bool+    , lint_spaceAfterComma :: !Bool+    , lint_maxLineLength :: !Int+    , lint_ignoreFiles :: ![String]++    , prettyprint_spaceBetweenParens :: !Bool+    , prettyprint_spaceBetweenBrackets :: !Bool+    , prettyprint_spaceBetweenBraces :: !Bool+    , prettyprint_spaceEmptyParens :: !Bool+    , prettyprint_spaceEmptyBraces :: !Bool+    , prettyprint_spaceAfterLabel :: !Bool+    , prettyprint_spaceBeforeComma :: !Bool+    , prettyprint_spaceAfterComma :: !Bool+    , prettyprint_semicolons :: !Bool+    , prettyprint_cStyle :: !Bool+    , prettyprint_removeRedundantParens :: !Bool+    , prettyprint_minimizeParens :: !Bool+    , prettyprint_assumeOperatorAssociativity :: !Bool+    , prettyprint_rejectInvalidCode :: !Bool+    , prettyprint_indentation :: !String++    , log_format :: !LogFormatChoice+    } deriving (Show)++defaultLintSettings :: LintSettings+defaultLintSettings =+    LintSettings+    { lint_maxScopeDepth = 7+    , lint_syntaxErrors = True+    , lint_syntaxInconsistencies = True+    , lint_deprecated = True+    , lint_trailingWhitespace = True+    , lint_whitespaceStyle = True+    , lint_beginnerMistakes = True+    , lint_emptyBlocks = True+    , lint_shadowing = True+    , lint_gotos = True+    , lint_goto_identifier = True+    , lint_doubleNegations = True+    , lint_redundantIfStatements = True+    , lint_redundantParentheses = True+    , lint_duplicateTableKeys = True+    , lint_profanity = True+    , lint_unusedVars = True+    , lint_unusedParameters = False+    , lint_unusedLoopVars = False+    , lint_inconsistentVariableStyle = False+    , lint_spaceBetweenParens = False+    , lint_spaceBetweenBrackets = False+    , lint_spaceBetweenBraces = False+    , lint_spaceBeforeComma = False+    , lint_spaceAfterComma = False+    , lint_maxLineLength = 0+    , lint_ignoreFiles = []++    , prettyprint_spaceBetweenParens = False+    , prettyprint_spaceBetweenBrackets = False+    , prettyprint_spaceBetweenBraces = False+    , prettyprint_spaceEmptyParens = True+    , prettyprint_spaceEmptyBraces = True+    , prettyprint_spaceAfterLabel = False+    , prettyprint_spaceBeforeComma = False+    , prettyprint_spaceAfterComma = True+    , prettyprint_semicolons = False+    , prettyprint_cStyle = False+    , prettyprint_removeRedundantParens = True+    , prettyprint_minimizeParens = False+    , prettyprint_assumeOperatorAssociativity = True+    , prettyprint_rejectInvalidCode = False+    , prettyprint_indentation = "    "++    , log_format = AutoLogFormatChoice+  }++instance FromJSON LintSettings where+    parseJSON (Object v) =+        LintSettings <$>+          v .:? "lint_maxScopeDepth" .!= lint_maxScopeDepth defaultLintSettings <*>+          v .:? "lint_syntaxErrors" .!= lint_syntaxErrors defaultLintSettings <*>+          v .:? "lint_syntaxInconsistencies" .!= lint_syntaxInconsistencies defaultLintSettings <*>+          v .:? "lint_deprecated" .!= lint_deprecated defaultLintSettings <*>+          v .:? "lint_trailingWhitespace" .!= lint_trailingWhitespace defaultLintSettings <*>+          v .:? "lint_whitespaceStyle" .!= lint_whitespaceStyle defaultLintSettings <*>+          v .:? "lint_beginnerMistakes" .!= lint_beginnerMistakes defaultLintSettings <*>+          v .:? "lint_emptyBlocks" .!= lint_emptyBlocks defaultLintSettings <*>+          v .:? "lint_shadowing" .!= lint_shadowing defaultLintSettings <*>+          v .:? "lint_gotos" .!= lint_gotos defaultLintSettings <*>+          v .:? "lint_goto_identifier" .!= lint_goto_identifier defaultLintSettings <*>+          v .:? "lint_doubleNegations" .!= lint_doubleNegations defaultLintSettings <*>+          v .:? "lint_redundantIfStatements" .!= lint_redundantIfStatements defaultLintSettings <*>+          v .:? "lint_redundantParentheses" .!= lint_redundantParentheses defaultLintSettings <*>+          v .:? "lint_duplicateTableKeys" .!= lint_duplicateTableKeys defaultLintSettings <*>+          v .:? "lint_profanity" .!= lint_profanity defaultLintSettings <*>+          v .:? "lint_unusedVars" .!= lint_unusedVars defaultLintSettings <*>+          v .:? "lint_unusedParameters" .!= lint_unusedParameters defaultLintSettings <*>+          v .:? "lint_unusedLoopVars" .!= lint_unusedLoopVars defaultLintSettings <*>+          v .:? "lint_inconsistentVariableStyle" .!= lint_inconsistentVariableStyle defaultLintSettings <*>++          -- Backwards compatible change: accept both the newer spaceBetween and the older+          -- spaceAfter+          (v .:? "lint_spaceBetweenParens" .!= lint_spaceBetweenParens defaultLintSettings <|>+          v .:? "lint_spaceAfterParens" .!= lint_spaceBetweenParens defaultLintSettings) <*>++          (v .:? "lint_spaceBetweenBrackets" .!= lint_spaceBetweenBrackets defaultLintSettings <|>+          v .:? "lint_spaceAfterBrackets" .!= lint_spaceBetweenBrackets defaultLintSettings) <*>++          (v .:? "lint_spaceBetweenBraces" .!= lint_spaceBetweenBraces defaultLintSettings <|>+          v .:? "lint_spaceAfterBraces" .!= lint_spaceBetweenBraces defaultLintSettings) <*>++          v .:? "lint_spaceBeforeComma" .!= lint_spaceBeforeComma defaultLintSettings <*>+          v .:? "lint_spaceAfterComma" .!= lint_spaceAfterComma defaultLintSettings <*>+          v .:? "lint_maxLineLength" .!= lint_maxLineLength defaultLintSettings <*>++          v .:? "lint_ignoreFiles" .!= lint_ignoreFiles defaultLintSettings <*>++          (v .:? "prettyprint_spaceBetweenParens" .!= prettyprint_spaceBetweenParens defaultLintSettings <|>+          v .:? "prettyprint_spaceAfterParens" .!= prettyprint_spaceBetweenParens defaultLintSettings) <*>++          (v .:? "prettyprint_spaceBetweenBrackets" .!= prettyprint_spaceBetweenBrackets defaultLintSettings <|>+          v .:? "prettyprint_spaceAfterBrackets" .!= prettyprint_spaceBetweenBrackets defaultLintSettings) <*>++          (v .:? "prettyprint_spaceBetweenBraces" .!= prettyprint_spaceBetweenBraces defaultLintSettings <|>+          v .:? "prettyprint_spaceAfterBraces" .!= prettyprint_spaceBetweenBraces defaultLintSettings) <*>++          v .:? "prettyprint_spaceEmptyParens" .!= prettyprint_spaceEmptyParens defaultLintSettings <*>+          v .:? "prettyprint_spaceEmptyBraces" .!= prettyprint_spaceEmptyBraces defaultLintSettings <*>+          v .:? "prettyprint_spaceAfterLabel" .!= prettyprint_spaceAfterLabel defaultLintSettings <*>+          v .:? "prettyprint_spaceBeforeComma" .!= prettyprint_spaceBeforeComma defaultLintSettings <*>+          v .:? "prettyprint_spaceAfterComma" .!= prettyprint_spaceAfterComma defaultLintSettings <*>+          v .:? "prettyprint_semicolons" .!= prettyprint_semicolons defaultLintSettings <*>+          v .:? "prettyprint_cStyle" .!= prettyprint_cStyle defaultLintSettings <*>+          v .:? "prettyprint_removeRedundantParens" .!= prettyprint_removeRedundantParens defaultLintSettings <*>+          v .:? "prettyprint_minimizeParens" .!= prettyprint_minimizeParens defaultLintSettings <*>+          v .:? "prettyprint_assumeOperatorAssociativity" .!= prettyprint_assumeOperatorAssociativity defaultLintSettings <*>+          v .:? "prettyprint_rejectInvalidCode" .!= prettyprint_rejectInvalidCode defaultLintSettings <*>+          v .:? "prettyprint_indentation" .!= prettyprint_indentation defaultLintSettings <*>+          v .:? "log_format" .!= log_format defaultLintSettings++    parseJSON _          = mzero++lint2ppSetting :: LintSettings -> PrettyPrintConfig+lint2ppSetting ls =+    PPConfig+    { spaceAfterParens = prettyprint_spaceBetweenParens ls+    , spaceAfterBrackets = prettyprint_spaceBetweenBrackets ls+    , spaceAfterBraces = prettyprint_spaceBetweenBraces ls+    , spaceEmptyParens = prettyprint_spaceEmptyParens ls+    , spaceEmptyBraces = prettyprint_spaceEmptyBraces ls+    , spaceAfterLabel = prettyprint_spaceAfterLabel ls+    , spaceBeforeComma = prettyprint_spaceBeforeComma ls+    , spaceAfterComma = prettyprint_spaceAfterComma ls+    , semicolons = prettyprint_semicolons ls+    , cStyle = prettyprint_cStyle ls+    , removeRedundantParens = prettyprint_removeRedundantParens ls+    , minimizeParens = prettyprint_minimizeParens ls+    , assumeOperatorAssociativity = prettyprint_assumeOperatorAssociativity ls+    , indentation = prettyprint_indentation ls+    }++instance ToJSON LintSettings where+    toJSON ls = object+        [ "lint_maxScopeDepth" .= lint_maxScopeDepth ls+        , "lint_syntaxErrors" .= lint_syntaxErrors ls+        , "lint_syntaxInconsistencies" .= lint_syntaxInconsistencies ls+        , "lint_deprecated" .= lint_deprecated ls+        , "lint_trailingWhitespace" .= lint_trailingWhitespace ls+        , "lint_whitespaceStyle" .= lint_whitespaceStyle ls+        , "lint_beginnerMistakes" .= lint_beginnerMistakes ls+        , "lint_emptyBlocks" .= lint_emptyBlocks ls+        , "lint_shadowing" .= lint_shadowing ls+        , "lint_gotos" .= lint_gotos ls+        , "lint_goto_identifier" .= lint_goto_identifier ls+        , "lint_doubleNegations" .= lint_doubleNegations ls+        , "lint_redundantIfStatements" .= lint_redundantIfStatements ls+        , "lint_redundantParentheses" .= lint_redundantParentheses ls+        , "lint_duplicateTableKeys" .= lint_duplicateTableKeys ls+        , "lint_profanity" .= lint_profanity ls+        , "lint_unusedVars" .= lint_unusedVars ls+        , "lint_unusedParameters" .= lint_unusedParameters ls+        , "lint_unusedLoopVars" .= lint_unusedLoopVars ls+        , "lint_inconsistentVariableStyle" .= lint_inconsistentVariableStyle ls+        , "lint_spaceBetweenParens" .= lint_spaceBetweenParens ls+        , "lint_spaceBetweenBrackets" .= lint_spaceBetweenBrackets ls+        , "lint_spaceBetweenBraces" .= lint_spaceBetweenBraces ls+        , "lint_maxLineLength" .= lint_maxLineLength ls+        , "lint_ignoreFiles" .= lint_ignoreFiles ls+        , "prettyprint_spaceBetweenParens" .= prettyprint_spaceBetweenParens ls+        , "prettyprint_spaceBetweenBrackets" .= prettyprint_spaceBetweenBrackets ls+        , "prettyprint_spaceBetweenBraces" .= prettyprint_spaceBetweenBraces ls+        , "prettyprint_spaceEmptyParens" .= prettyprint_spaceEmptyParens ls+        , "prettyprint_spaceEmptyBraces" .= prettyprint_spaceEmptyBraces ls+        , "prettyprint_spaceAfterLabel" .= prettyprint_spaceAfterLabel ls+        , "prettyprint_spaceBeforeComma" .= prettyprint_spaceBeforeComma ls+        , "prettyprint_spaceAfterComma" .= prettyprint_spaceAfterComma ls+        , "prettyprint_semicolons" .= prettyprint_semicolons ls+        , "prettyprint_cStyle" .= prettyprint_cStyle ls+        , "prettyprint_removeRedundantParens" .= prettyprint_removeRedundantParens ls+        , "prettyprint_minimizeParens" .= prettyprint_minimizeParens ls+        , "prettyprint_assumeOperatorAssociativity" .= prettyprint_assumeOperatorAssociativity ls+        , "prettyprint_rejectInvalidCode" .= prettyprint_rejectInvalidCode ls+        , "prettyprint_indentation" .= prettyprint_indentation ls+        , "log_format" .= log_format ls+        ]