docs: update readme

* Save jobf when decompiling to Java through the cli
* Skip jobf saving if it's empty
* Update jadx-core/src/main/java/jadx/core/deobf/DeobfPresets.java

Co-authored-by: Yotam Nachum <me@yotam.net>
Co-authored-by: skylot <118523+skylot@users.noreply.github.com>

.editorconfig

@@ -0,0 +1,20 @@
+# EditorConfig is awesome: https://EditorConfig.org
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+indent_style = tab
+tab_width = 4
+continuation_indent_size = 8 #IntelliJ Idea specific workaround
+
+charset = utf-8
+trim_trailing_whitespace = true
+
+[*.yml]
+indent_style = space
+indent_size = 2
+
+[*.bat]
+end_of_line = crlf

.github/ISSUE_TEMPLATE/decompilation-error.md

@@ -0,0 +1,19 @@
+---
+name: Decompilation error
+about: Create a report to help us improve jadx decompiler
+title: "[core]"
+labels: Core, bug
+assignees: ''
+
+---
+
+**Checks before report**
+- check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+- search existing issues by exception message
+
+**Describe error**
+- full name of method or class with error
+- full java stacktrace (no need to copy method fallback code (commented pseudocode))
+- **IMPORTANT!** attach or provide link to apk file (double check apk version)
+
+  **Note**: GitHub don't allow attach files with `.apk` extension, but you can change extension by adding `.zip` at the end :)

.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,10 @@
+---
+name: Feature Request
+about: Suggest an idea for jadx
+title: "[feature]"
+labels: new feature
+assignees: ''
+
+---
+
+*Describe your idea:*

.github/pull_request_template.md

@@ -0,0 +1,5 @@
+:exclamation: Please review the [guidelines for contributing](https://github.com/skylot/jadx/blob/master/CONTRIBUTING.md#Pull-Request-Process)
+
+### Description
+Please describe your pull request.
+Reference issue it fixes.

.github/workflows/build.yml

@@ -0,0 +1,52 @@
+name: Build
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: actions/setup-java@v1
+        with:
+          java-version: 8
+
+      - name: Set jadx version
+        run: |
+          JADX_LAST_TAG=$(git describe --abbrev=0 --tags)
+          JADX_VERSION="${JADX_LAST_TAG:1}.$GITHUB_RUN_NUMBER-${GITHUB_SHA:0:8}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - uses: burrunan/gradle-cache-action@v1
+        name: Build with Gradle
+        env:
+          TERM: dumb
+          TEST_INPUT_PLUGIN: dx
+        with:
+          arguments: clean build dist copyExe --warning-mode=all
+
+      - name: Save bundle artifact
+        if: success() && github.event_name == 'push'
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ format('jadx-{0}', env.JADX_VERSION) }}
+          # Waiting fix for https://github.com/actions/upload-artifact/issues/39 to upload zip file
+          # Upload unpacked files for now
+          path: build/jadx/**/*
+          if-no-files-found: error
+
+      - name: Save exe artifact
+        if: success() && github.event_name == 'push'
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ format('jadx-gui-{0}-no-jre-win.exe', env.JADX_VERSION) }}
+          path: build/*.exe
+          if-no-files-found: error

.github/workflows/gradle-wrapper-validation.yml

@@ -0,0 +1,10 @@
+name: "Validate Gradle Wrapper"
+on: [push]
+
+jobs:
+  validation:
+    name: "Validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: gradle/wrapper-validation-action@v1

.gitignore

@@ -5,23 +5,32 @@
 
 # IntelliJ Idea files
 .idea/
+.run/
 out/
 *.iml
 *.ipr
 *.iws
+.attach_pid*
+*.hprof
+
+**/.DS_Store
 
 bin/
 target/
 build/
+classes/
 idea/
 .gradle/
-gradle.properties
+node_modules/
 
+jadx-output/
 *-tmp/
+**/tmp/
+*.jobf
 
-*.dex
 *.class
 *.dump
 *.log
 *.cfg
-
+*.orig
+quark.json

.gitlab-ci.yml

@@ -0,0 +1,24 @@
+variables:
+  GRADLE_OPTS: "-Dorg.gradle.daemon=false"
+  TERM: "dumb"
+
+before_script:
+  - chmod +x gradlew
+
+stages:
+  - test
+
+java-8:
+  stage: test
+  image: openjdk:8
+  script: ./gradlew clean build dist copyExe --warning-mode=all
+
+java-11:
+  stage: test
+  image: openjdk:11
+  script: ./gradlew clean build dist copyExe --warning-mode=all
+
+java-latest:
+  stage: test
+  image: openjdk:latest
+  script: java -version && ./gradlew clean build dist --warning-mode=all

.travis.yml

@@ -1,12 +0,0 @@
-language: java
-jdk:
-    - oraclejdk7
-    - openjdk7
-    - openjdk6
-before_install:
-    - chmod +x gradlew
-script:
-    - TERM=dumb ./gradlew clean build dist
-notifications:
-    email:
-        - skylot@gmail.com

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at skylot@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -0,0 +1,32 @@
+# Contributing
+
+Please note we have a [code of conduct](CODE_OF_CONDUCT.md), please follow it in all your interactions with the project.
+
+## Open Issue
+
+1. Before proceed please do:
+    - check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+    - search existing issues by exception message
+
+2. Describe error
+    **Describe error**
+    - full name of method or class with error
+    - full java stacktrace (no need to copy method fallback code (commented pseudocode))
+    - **IMPORTANT!:** attach or provide link to apk file (double check apk version)
+
+      **Note**: GitHub don't allow attach files with `.apk` extension, but you can change extension by adding `.zip` at the end :)
+
+
+## Pull Request Process
+
+1. Please don't submit any code style fixes, dependencies updates or other changes which are not fixing any issues.
+
+1. Before start working on PR please discuss the change you wish to make via issue. PR without corresponding issue will be rejected.
+
+1. Use only features and API from Java 8 or below.
+
+1. If possible don't add additional dependencies especially if they are big.
+
+1. Make sure your code is correctly formatted, see description here: [Code Formatting](https://github.com/skylot/jadx/wiki/Code-Formatting).
+
+1. Make sure your changes is passing build: `./gradlew clean build dist`

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -1,8 +1,8 @@
 The majority of jadx is written and copyrighted by me (Skylot)
-and released under the Apache 2.0 license:
+and released under the Apache 2.0 license (see LICENSE file for full license text):
 
 *******************************************************************************
-Copyright 2013, Skylot
+Copyright 2015, Skylot
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,8 +18,8 @@ limitations under the License.
 *******************************************************************************
 
 
-Various portions of the code including dx library are taken from 
-the Android Open Source Project, and are used in accordance with 
+Various portions of the code including dx library are taken from
+the Android Open Source Project, and are used in accordance with
 the following license:
 
 *******************************************************************************
@@ -74,10 +74,10 @@ Copyright (c) 2004-2011 QOS.ch
  distribute,  sublicense, and/or sell  copies of  the Software,  and to
  permit persons to whom the Software  is furnished to do so, subject to
  the following conditions:
- 
+
  The  above  copyright  notice  and  this permission  notice  shall  be
  included in all copies or substantial portions of the Software.
- 
+
  THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
  EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
  MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
@@ -92,24 +92,60 @@ Logback source code and binaries are dual-licensed under the EPL v1.0 and the LG
 
 *******************************************************************************
 Logback: the reliable, generic, fast and flexible logging framework.
-Copyright (C) 1999-2012, QOS.ch. All rights reserved. 
+Copyright (C) 1999-2012, QOS.ch. All rights reserved.
 
 This program and the accompanying materials are dual-licensed under
 either the terms of the Eclipse Public License v1.0 as published by
 the Eclipse Foundation
- 
+
   or (per the licensee's choosing)
- 
+
 under the terms of the GNU Lesser General Public License version 2.1
 as published by the Free Software Foundation.
 *******************************************************************************
 
 
+ASM library:
+
+*******************************************************************************
+Copyright (c) 2000-2011 INRIA, France Telecom
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holders nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************
+
+
 
 Jadx-gui components
 ===================
 
-RSyntaxTextArea library licensed under modified BSD liense:
+RSyntaxTextArea library (https://github.com/bobbylight/RSyntaxTextArea)
+licensed under modified BSD license:
 
 *******************************************************************************
 Copyright (c) 2012, Robert Futrell
@@ -139,7 +175,39 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************
 
 
+Concurrent Trees (https://code.google.com/p/concurrent-trees/)
+licenced under Apache License 2.0:
+
+*******************************************************************************
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*******************************************************************************
+
+
+Image Viewer (https://github.com/kazocsaba/imageviewer)
+
+*******************************************************************************
+Copyright (c) 2008-2012 Kazó Csaba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*******************************************************************************
+
+JFontChooser Component - http://sourceforge.jp/projects/jfontchooser/
+
 Icons copied from several places:
  - Eclipse Project (JDT UI) - licensed under EPL v1.0 (http://www.eclipse.org/legal/epl-v10.html)
- - famfamfam silk icon set (http://www.famfamfam.com/lab/icons/silk/) - licensed under Creative Commons Attribution 2.5 License (http://creativecommons.org/licenses/by/2.5/)
-
+ - famfamfam silk icon set (http://www.famfamfam.com/lab/icons/silk/) - licensed
+     under Creative Commons Attribution 2.5 License (http://creativecommons.org/licenses/by/2.5/)

README.md

@@ -1,54 +1,128 @@
-## JADX 
+<img src="https://raw.githubusercontent.com/skylot/jadx/master/jadx-gui/src/main/resources/logos/jadx-logo.png" width="64" align="left" />
+
+## JADX
+
+[![Build status](https://github.com/skylot/jadx/workflows/Build/badge.svg)](https://github.com/skylot/jadx/actions?query=workflow%3ABuild)
+[![Alerts from lgtm.com](https://img.shields.io/lgtm/alerts/g/skylot/jadx.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/skylot/jadx/alerts/)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
+[![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)
+
 **jadx** - Dex to Java decompiler
 
-Command line and GUI tools for produce Java source code from Android Dex and Apk files
+Command line and GUI tools for producing Java source code from Android Dex and Apk files
 
-Note: jadx-gui now in experimental stage
+**Main features:**
+- decompile Dalvik bytecode to java classes from APK, dex, aar, aab and zip files
+- decode `AndroidManifest.xml` and other resources from `resources.arsc`
+- deobfuscator included
 
+**jadx-gui features:**
+- view decompiled code with highlighted syntax
+- jump to declaration
+- find usage
+- full text search
+- smali debugger (thanks to [@LBJ-the-GOAT](https://github.com/LBJ-the-GOAT)), check [wiki page](https://github.com/skylot/jadx/wiki/Smali-debugger) for setup and usage
 
-### Downloads
-- [unstable](https://drone.io/github.com/skylot/jadx/files)
-[![Build Status](https://drone.io/github.com/skylot/jadx/status.png)](https://drone.io/github.com/skylot/jadx/latest)
-[![Build Status](https://travis-ci.org/skylot/jadx.png?branch=master)](https://travis-ci.org/skylot/jadx)
-- from [github](https://github.com/skylot/jadx/releases)
-- from [sourceforge](http://sourceforge.net/projects/jadx/files/) 
+See these features in action here: [jadx-gui features overview](https://github.com/skylot/jadx/wiki/jadx-gui-features-overview)
 
+<img src="https://user-images.githubusercontent.com/118523/142730720-839f017e-38db-423e-b53f-39f5f0a0316f.png" width="700"/>
+
+### Download
+- release from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
+- latest [unstable build](https://nightly.link/skylot/jadx/workflows/build/master)
+
+After download unpack zip file go to `bin` directory and run:
+- `jadx` - command line version
+- `jadx-gui` - UI version
+
+On Windows run `.bat` files with double-click\
+**Note:** ensure you have installed Java 11 or later 64-bit version.
+For windows you can download it from [oracle.com](https://www.oracle.com/java/technologies/downloads/#jdk17-windows) (select x64 Installer).
+
+### Install
+1. Arch linux
+    ```bash
+        sudo pacman -S jadx
+    ```
+2. macOS
+    ```bash
+        brew install jadx
+    ```
+
+### Build from source
+JDK 8 or higher must be installed:
+```
+git clone https://github.com/skylot/jadx.git
+cd jadx
+./gradlew dist
+```
 
-### Building from source  
-    git clone https://github.com/skylot/jadx.git
-    cd jadx
-    ./gradlew dist
-    
 (on Windows, use `gradlew.bat` instead of `./gradlew`)
 
 Scripts for run jadx will be placed in `build/jadx/bin`
 and also packed to `build/jadx-<version>.zip`
 
-
-### Run
-Run **jadx** on itself:
-
-    cd build/jadx/
-    bin/jadx -d out lib/jadx-core-*.jar
-    #or
-    bin/jadx-gui lib/jadx-core-*.jar
-
-
 ### Usage
 ```
-jadx[-gui] [options] <input file> (.dex, .apk or .jar)
+jadx[-gui] [options] <input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab)
 options:
- -d, --output-dir    - output directory
- -j, --threads-count - processing threads count
- -f, --fallback      - make simple dump (using goto instead of 'if', 'for', etc)
-     --cfg           - save methods control flow graph to dot file
-     --raw-cfg       - save methods control flow graph (use raw instructions)
- -v, --verbose       - verbose output
- -h, --help          - print this help
-Example:
- jadx -d out classes.dex
+  -d, --output-dir                    - output directory
+  -ds, --output-dir-src               - output directory for sources
+  -dr, --output-dir-res               - output directory for resources
+  -r, --no-res                        - do not decode resources
+  -s, --no-src                        - do not decompile source code
+  --single-class                      - decompile a single class
+  --output-format                     - can be 'java' or 'json', default: java
+  -e, --export-gradle                 - save as android gradle project
+  -j, --threads-count                 - processing threads count, default: 4
+  --show-bad-code                     - show inconsistent code (incorrectly decompiled)
+  --no-imports                        - disable use of imports, always write entire package name
+  --no-debug-info                     - disable debug info
+  --add-debug-lines                   - add comments with debug line numbers if available
+  --no-inline-anonymous               - disable anonymous classes inline
+  --no-inline-methods                 - disable methods inline
+  --no-replace-consts                 - don't replace constant value with matching constant field
+  --escape-unicode                    - escape non latin characters in strings (with \u)
+  --respect-bytecode-access-modifiers - don't change original access modifiers
+  --deobf                             - activate deobfuscation
+  --deobf-min                         - min length of name, renamed if shorter, default: 3
+  --deobf-max                         - max length of name, renamed if longer, default: 64
+  --deobf-cfg-file                    - deobfuscation map file, default: same dir and name as input file with '.jobf' extension
+  --deobf-rewrite-cfg                 - force to ignore and overwrite deobfuscation map file
+  --deobf-use-sourcename              - use source file name as class name alias
+  --deobf-parse-kotlin-metadata       - parse kotlin metadata to class and package names
+  --rename-flags                      - fix options (comma-separated list of):
+                                         'case' - fix case sensitivity issues (according to --fs-case-sensitive option),
+                                         'valid' - rename java identifiers to make them valid,
+                                         'printable' - remove non-printable chars from identifiers,
+                                        or single 'none' - to disable all renames
+                                        or single 'all' - to enable all (default)
+  --fs-case-sensitive                 - treat filesystem as case sensitive, false by default
+  --cfg                               - save methods control flow graph to dot file
+  --raw-cfg                           - save methods control flow graph (use raw instructions)
+  -f, --fallback                      - make simple dump (using goto instead of 'if', 'for', etc)
+  --comments-level                    - set code comments level, values: none, user_only, error, warn, info, debug, default: info
+  --log-level                         - set log level, values: quiet, progress, error, warn, info, debug, default: progress
+  -v, --verbose                       - verbose output (set --log-level to DEBUG)
+  -q, --quiet                         - turn off output (set --log-level to QUIET)
+  --version                           - print jadx version
+  -h, --help                          - print this help
+Examples:
+  jadx -d out classes.dex
+  jadx --rename-flags "none" classes.dex
+  jadx --rename-flags "valid, printable" classes.dex
+  jadx --log-level ERROR app.apk
 ```
+These options also worked on jadx-gui running from command line and override options from preferences dialog
 
+### Troubleshooting
+Please check wiki page [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A)
+
+### Contributing
+To support this project you can:
+  - Post thoughts about new features/optimizations that important to you
+  - Submit decompilation issues, please read before proceed: [Open issue](CONTRIBUTING.md#Open-Issue)
+  - Open pull request, please follow these rules: [Pull Request Process](CONTRIBUTING.md#Pull-Request-Process)
+
+---------------------------------------
 *Licensed under the Apache 2.0 License*
-
-*Copyright 2013 by Skylot*

build.gradle

@@ -1,70 +1,165 @@
-ext.jadxVersion = file('version').readLines().get(0)
-
-apply plugin: 'sonar-runner'
-
-subprojects {
-    apply plugin: 'java'
-    apply plugin: 'idea'
-    apply plugin: 'eclipse'
-
-    sourceCompatibility = 1.6
-    targetCompatibility = 1.6
-
-    version = jadxVersion
-
-    gradle.projectsEvaluated {
-        tasks.withType(Compile) {
-            if (!"${it}".contains(":jadx-samples:")) {
-                options.compilerArgs << "-Xlint" << "-Xlint:unchecked" << "-Xlint:deprecation"
-            }
-        }
-    }
-
-    jar {
-        version = jadxVersion
-        manifest {
-            mainAttributes('jadx-version' : jadxVersion)
-        }
-    }
-
-    dependencies {
-        compile 'org.slf4j:slf4j-api:1.7.5'
-        testCompile 'junit:junit:4.11'
-        testCompile "org.mockito:mockito-core:1.9.5"
-    }
-
-    repositories {
-        mavenCentral()
-    }
+plugins {
+	id 'com.github.ben-manes.versions' version '0.39.0'
+	id 'com.diffplug.spotless' version '6.0.0'
 }
 
-task copyArtifacts(type: Sync, dependsOn: ['jadx-cli:installApp', 'jadx-gui:installApp']) {
-    destinationDir file("$buildDir/jadx")
-    ['jadx-cli', 'jadx-gui'].each {
-        from tasks.getByPath(":${it}:installApp").destinationDir
-    }
+ext.jadxVersion = System.getenv('JADX_VERSION') ?: "dev"
+version = jadxVersion
+println("jadx version: ${jadxVersion}")
+
+allprojects {
+	apply plugin: 'java'
+	apply plugin: 'checkstyle'
+	apply plugin: 'maven-publish'
+
+	version = jadxVersion
+
+	sourceCompatibility = JavaVersion.VERSION_1_8
+	targetCompatibility = JavaVersion.VERSION_1_8
+
+	compileJava {
+		options.encoding = "UTF-8"
+	}
+
+	jar {
+		manifest {
+			mainAttributes('jadx-version': jadxVersion)
+		}
+	}
+
+	publishing {
+		publications {
+			mavenJava(MavenPublication) {
+				from components.java
+			}
+		}
+	}
+
+	dependencies {
+		implementation 'org.slf4j:slf4j-api:1.7.32'
+		compileOnly 'org.jetbrains:annotations:23.0.0'
+
+		testImplementation 'ch.qos.logback:logback-classic:1.2.7'
+		testImplementation 'org.hamcrest:hamcrest-library:2.2'
+		testImplementation 'org.mockito:mockito-core:4.1.0'
+		testImplementation 'org.assertj:assertj-core:3.21.0'
+
+		testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
+		testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
+
+		testImplementation 'org.eclipse.jdt.core.compiler:ecj:4.6.1'
+		testCompileOnly 'org.jetbrains:annotations:23.0.0'
+	}
+
+	test {
+		useJUnitPlatform()
+	}
+
+	repositories {
+		mavenLocal()
+		mavenCentral()
+		google()
+	}
 }
 
-task pack(type: Zip, dependsOn: copyArtifacts) {
-    destinationDir buildDir
-    archiveName "jadx-${jadxVersion}.zip"
-    from copyArtifacts.destinationDir
+spotless {
+	java {
+		target fileTree(rootDir).matching {
+			include 'jadx-cli/src/**/java/**/*.java'
+			include 'jadx-core/src/**/java/**/*.java'
+			include 'jadx-gui/src/**/java/**/*.java'
+			include 'jadx-plugins/**/java/**/*.java'
+		}
+
+		importOrderFile 'config/code-formatter/eclipse.importorder'
+		eclipse().configFile 'config/code-formatter/eclipse.xml'
+		if (JavaVersion.current() < JavaVersion.VERSION_16) {
+			removeUnusedImports()
+		} else {
+			// google-format broken on java 16 (https://github.com/diffplug/spotless/issues/834)
+			println('Warning! Unused imports remove is disabled for Java 16')
+		}
+
+		lineEndings(com.diffplug.spotless.LineEnding.UNIX)
+		encoding("UTF-8")
+		trimTrailingWhitespace()
+		endWithNewline()
+	}
+	format 'misc', {
+		target '**/*.gradle', '**/*.md', '**/*.xml', '**/.gitignore', '**/.properties'
+		targetExclude ".gradle/**", ".idea/**", "*/build/**"
+
+		lineEndings(com.diffplug.spotless.LineEnding.UNIX)
+		encoding("UTF-8")
+		trimTrailingWhitespace()
+		endWithNewline()
+	}
 }
 
-task dist(dependsOn: pack) {
-    description = 'Build jadx distribution zip'
+dependencyUpdates {
+	resolutionStrategy {
+		componentSelection { rules ->
+			rules.all { ComponentSelection selection ->
+				boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm', 'atlassian'].any { qualifier ->
+					selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
+				}
+				if (rejected) {
+					selection.reject('Release candidate')
+				}
+			}
+		}
+	}
 }
 
-task samples(dependsOn: 'jadx-samples:samples') {
+task copyArtifacts(type: Copy) {
+	from tasks.getByPath(":jadx-cli:installDist")
+	from tasks.getByPath(":jadx-gui:installDist")
+	into layout.buildDirectory.dir("jadx")
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 }
 
-task build(dependsOn: [dist, samples]) {
+task pack(type: Zip) {
+	from copyArtifacts
+	archiveFileName = "jadx-${jadxVersion}.zip"
+	destinationDirectory = layout.buildDirectory
 }
 
-task clean(type: Delete) {
-    delete buildDir
+task copyExe(type: Copy) {
+	group 'jadx'
+	description = 'Copy exe to build dir'
+	mustRunAfter pack // not needed, but gradle throws warning because of same output dir
+
+	from tasks.getByPath('jadx-gui:createExe')
+	include '*.exe'
+	into layout.buildDirectory
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 }
 
-task wrapper(type: Wrapper) {
-    gradleVersion = '1.9'
+task dist {
+	group 'jadx'
+	description = 'Build jadx distribution zip'
+
+	dependsOn(pack)
+
+	OperatingSystem os = org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.currentOperatingSystem;
+	if (os.isWindows()) {
+		dependsOn('copyExe')
+	}
 }
+
+task distWin(type: Copy, dependsOn: 'jadx-gui:distWinWithJre') {
+	group 'jadx'
+	description = 'Copy bundle to build dir'
+	destinationDir buildDir
+	from(tasks.getByPath('jadx-gui:distWinWithJre').outputs) {
+		include '*.zip'
+	}
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+task cleanBuildDir(type: Delete) {
+	group 'jadx'
+	delete buildDir
+}
+
+clean.dependsOn(cleanBuildDir)

config/checkstyle/checkstyle.xml

@@ -0,0 +1,131 @@
+<?xml version="1.0" ?>
+
+<!DOCTYPE module PUBLIC
+		"-//Puppy Crawl//DTD Check Configuration 1.2//EN"
+		"http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
+
+<module name="Checker">
+	<property name="fileExtensions" value="java, properties, xml"/>
+	<property name="charset" value="UTF-8"/>
+
+	<module name="TreeWalker">
+		<property name="tabWidth" value="4"/>
+		<module name="RegexpSinglelineJava">
+			<property name="format" value="^\t* "/>
+			<property name="message" value="Indent must use tab characters"/>
+			<property name="ignoreComments" value="true"/>
+		</module>
+		<module name="RegexpSinglelineJava">
+			<property name="format" value="^(?!\s+\* $).*?\s+$"/>
+			<property name="message" value="Line has trailing spaces."/>
+		</module>
+		<module name="AvoidEscapedUnicodeCharacters">
+			<property name="allowEscapesForControlCharacters" value="true"/>
+			<property name="allowByTailComment" value="true"/>
+			<property name="allowNonPrintableEscapes" value="true"/>
+		</module>
+
+		<module name="EmptyLineSeparator">
+			<property name="allowNoEmptyLineBetweenFields" value="true"/>
+			<property name="allowMultipleEmptyLines" value="false"/>
+		</module>
+
+		<!-- whitespaces -->
+		<module name="SingleSpaceSeparator"/>
+		<module name="GenericWhitespace"/>
+		<module name="MethodParamPad"/>
+		<module name="NoWhitespaceBefore"/>
+		<module name="OperatorWrap"/>
+		<module name="ParenPad"/>
+		<module name="TypecastParenPad"/>
+		<module name="WhitespaceAfter"/>
+		<module name="WhitespaceAround">
+			<property name="allowEmptyMethods" value="true"/>
+		</module>
+		<!-- <module name="EmptyForIteratorPad"/> -->
+		<!-- <module name="NoWhitespaceAfter"/>-->
+
+		<module name="NoLineWrap"/>
+
+		<module name="IllegalImport"/> <!-- defaults to sun.* packages -->
+		<module name="RedundantImport"/>
+		<module name="UnusedImports"/>
+		<!-- <module name="AvoidStarImport"/> -->
+
+		<module name="NeedBraces"/>
+		<module name="LeftCurly"/>
+		<module name="RightCurly"/>
+		<module name="EmptyCatchBlock">
+			<property name="exceptionVariableName" value="expected|ignore"/>
+		</module>
+
+		<!-- naming -->
+		<module name="PackageName"/>
+		<module name="TypeName"/>
+		<module name="InterfaceTypeParameterName"/>
+		<module name="ClassTypeParameterName"/>
+		<module name="StaticVariableName"/>
+		<module name="ConstantName"/>
+		<module name="MemberName"/>
+		<module name="MethodName"/>
+		<module name="MethodTypeParameterName"/>
+		<module name="ParameterName"/>
+		<module name="LambdaParameterName"/>
+		<module name="LocalVariableName"/>
+		<module name="LocalFinalVariableName"/>
+		<module name="CatchParameterName"/>
+		<!-- <module name="HiddenField"/> -->
+
+		<!-- annotations -->
+		<module name="AnnotationLocation"/>
+		<module name="AnnotationUseStyle">
+			<property name="elementStyle" value="compact"/>
+		</module>
+		<module name="MissingOverride"/>
+		<!-- <module name="MissingDeprecated"/> -->
+
+		<module name="ModifierOrder"/>
+		<!-- <module name="RedundantModifier"/> -->
+		<!-- <module name="ParameterNumber"/> -->
+
+		<module name="EmptyStatement"/>
+		<module name="DefaultComesLast"/>
+		<module name="EqualsHashCode"/>
+		<module name="FallThrough"/>
+		<!-- <module name="IllegalCatch"/> -->
+		<module name="IllegalThrows"/>
+		<module name="IllegalType"/>
+		<module name="InnerAssignment"/>
+		<module name="MultipleVariableDeclarations"/>
+		<module name="NoClone"/>
+		<module name="NoFinalizer"/>
+		<module name="OneStatementPerLine"/>
+		<module name="PackageDeclaration"/>
+		<module name="StringLiteralEquality"/>
+
+		<!-- design -->
+		<module name="OneTopLevelClass"/>
+		<module name="MutableException"/>
+		<module name="InterfaceIsType"/>
+		<module name="ThrowsCount">
+			<property name="max" value="2"/>
+		</module>
+
+		<!-- misc -->
+		<module name="ArrayTypeStyle"/>
+		<module name="OuterTypeFilename"/>
+
+		<!-- sizes -->
+		<module name="OuterTypeNumber"/>
+
+		<module name="SuppressWarningsHolder"/>
+
+		<module name="IllegalType"/>
+		<module name="IllegalImport">
+			<property name="illegalClasses" value="jadx.core.utils.DebugUtils"/>
+		</module>
+	</module>
+
+	<module name="NewlineAtEndOfFile"/>
+	<module name="SuppressWarningsFilter"/>
+</module>

config/code-formatter/eclipse.importorder

@@ -0,0 +1,8 @@
+#Import Order
+0=java
+1=javax
+2=org
+3=com
+4=
+5=jadx
+6=\#

config/code-formatter/eclipse.xml

@@ -0,0 +1,348 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="16">
+    <profile kind="CodeFormatterProfile" name="jadx eclipse" version="16">
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indentation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_with_spaces" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.disabling_tag" value="@formatter:off"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="48"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_root_tags" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.enabling_tag" value="@formatter:on"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_logical_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="100"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_on_off_tags" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_method_body_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_additive_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_shift_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_lambda_body" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.compact_else_if" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_parameters" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_loops" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_relational_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation" value="separate_lines_if_wrapped"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_line_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_type_members_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_module_statements" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="48"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_method_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_wrapped_lines" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_conditional_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_shift_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines" value="2147483647"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_resources_in_try" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_code_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_source_code" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_field" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_method" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assignment_operator" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_switch" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_html" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_if" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_arguments" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_label" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_member_type" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_relational_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_block_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_tag_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_string_concatenation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_logical_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_package" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_additive_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_lines_in_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_parameter_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="tab"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_string_concatenation" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.lineSplit" value="140"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
+    </profile>
+</profiles>

gradle.properties

@@ -0,0 +1,2 @@
+org.gradle.daemon=false
+org.gradle.warning.mode=all

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionSha256Sum=de8f52ad49bdc759164f72439a3bf56ddb1589c4cde802d3cec7d6ad0e0ee410
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.9-bin.zip

gradlew

@@ -1,79 +1,129 @@
-#!/usr/bin/env bash
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
-warn ( ) {
+warn () {
     echo "$*"
-}
+} >&2
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
-APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -82,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -90,75 +140,95 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
-}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,3 +1,19 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -8,20 +24,23 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -35,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -45,34 +64,14 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windowz variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

jadx-cli/build.gradle

@@ -1,28 +1,29 @@
-apply plugin: 'application'
-
-mainClassName = 'jadx.cli.JadxCLI'
-applicationName = 'jadx'
-
-dependencies {
-    compile(project(':jadx-core'))
-    compile 'com.beust:jcommander:1.30'
+plugins {
+	id 'application'
 }
 
-startScripts {
-    doLast {
-        // increase default max heap size
-        String var = 'DEFAULT_JVM_OPTS='
-        String args = '-Xmx1300M'
-        unixScript.text = unixScript.text.replace(var + '""', var + '"' + args + '"')
-        windowsScript.text = windowsScript.text.replace(var, var + args)
-    }
+dependencies {
+	implementation(project(':jadx-core'))
+
+	runtimeOnly(project(':jadx-plugins:jadx-dex-input'))
+	runtimeOnly(project(':jadx-plugins:jadx-java-input'))
+	runtimeOnly(project(':jadx-plugins:jadx-smali-input'))
+
+	implementation 'com.beust:jcommander:1.81'
+	implementation 'ch.qos.logback:logback-classic:1.2.7'
+}
+
+application {
+	applicationName = 'jadx'
+	mainClass.set('jadx.cli.JadxCLI')
+	applicationDefaultJvmArgs = ['-Xms128M', '-Xmx4g', '-XX:+UseG1GC']
 }
 
 applicationDistribution.with {
-    into('') {
-        from '../.'
-        include 'README.md'
-        include 'NOTICE'
-    }
+	into('') {
+		from '../.'
+		include 'README.md'
+		include 'NOTICE'
+		include 'LICENSE'
+	}
 }
-

jadx-cli/src/main/java/jadx/cli/JCommanderWrapper.java

@@ -0,0 +1,148 @@
+package jadx.cli;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import org.jetbrains.annotations.Nullable;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.ParameterDescription;
+import com.beust.jcommander.ParameterException;
+import com.beust.jcommander.Parameterized;
+
+import jadx.api.JadxDecompiler;
+
+public class JCommanderWrapper<T> {
+	private final JCommander jc;
+
+	public JCommanderWrapper(T obj) {
+		this.jc = JCommander.newBuilder().addObject(obj).build();
+	}
+
+	public boolean parse(String[] args) {
+		try {
+			jc.parse(args);
+			return true;
+		} catch (ParameterException e) {
+			System.err.println("Arguments parse error: " + e.getMessage());
+			printUsage();
+			return false;
+		}
+	}
+
+	public void overrideProvided(T obj) {
+		List<ParameterDescription> fieldsParams = jc.getParameters();
+		List<ParameterDescription> parameters = new ArrayList<>(1 + fieldsParams.size());
+		parameters.add(jc.getMainParameterValue());
+		parameters.addAll(fieldsParams);
+		for (ParameterDescription parameter : parameters) {
+			if (parameter.isAssigned()) {
+				// copy assigned field value to obj
+				Parameterized parameterized = parameter.getParameterized();
+				Object val = parameterized.get(parameter.getObject());
+				parameterized.set(obj, val);
+			}
+		}
+	}
+
+	public void printUsage() {
+		// print usage in not sorted fields order (by default its sorted by description)
+		PrintStream out = System.out;
+		out.println();
+		out.println("jadx - dex to java decompiler, version: " + JadxDecompiler.getVersion());
+		out.println();
+		out.println("usage: jadx [options] " + jc.getMainParameterDescription());
+		out.println("options:");
+
+		List<ParameterDescription> params = jc.getParameters();
+		Map<String, ParameterDescription> paramsMap = new LinkedHashMap<>(params.size());
+		int maxNamesLen = 0;
+		for (ParameterDescription p : params) {
+			paramsMap.put(p.getParameterized().getName(), p);
+			int len = p.getNames().length();
+			if (len > maxNamesLen) {
+				maxNamesLen = len;
+			}
+		}
+
+		JadxCLIArgs args = (JadxCLIArgs) jc.getObjects().get(0);
+		for (Field f : getFields(args.getClass())) {
+			String name = f.getName();
+			ParameterDescription p = paramsMap.get(name);
+			if (p == null) {
+				continue;
+			}
+			StringBuilder opt = new StringBuilder();
+			opt.append("  ").append(p.getNames());
+			String description = p.getDescription();
+			addSpaces(opt, maxNamesLen - opt.length() + 3);
+			if (description.contains("\n")) {
+				String[] lines = description.split("\n");
+				opt.append("- ").append(lines[0]);
+				for (int i = 1; i < lines.length; i++) {
+					opt.append('\n');
+					addSpaces(opt, maxNamesLen + 5);
+					opt.append(lines[i]);
+				}
+			} else {
+				opt.append("- ").append(description);
+			}
+			String defaultValue = getDefaultValue(args, f, opt);
+			if (defaultValue != null) {
+				opt.append(", default: ").append(defaultValue);
+			}
+			out.println(opt);
+		}
+		out.println("Examples:");
+		out.println("  jadx -d out classes.dex");
+		out.println("  jadx --rename-flags \"none\" classes.dex");
+		out.println("  jadx --rename-flags \"valid, printable\" classes.dex");
+		out.println("  jadx --log-level ERROR app.apk");
+	}
+
+	/**
+	 * Get all declared fields of the specified class and all super classes
+	 */
+	private List<Field> getFields(Class<?> clazz) {
+		List<Field> fieldList = new ArrayList<>();
+		while (clazz != null) {
+			fieldList.addAll(Arrays.asList(clazz.getDeclaredFields()));
+			clazz = clazz.getSuperclass();
+		}
+		return fieldList;
+	}
+
+	@Nullable
+	private String getDefaultValue(JadxCLIArgs args, Field f, StringBuilder opt) {
+		try {
+			Class<?> fieldType = f.getType();
+			if (fieldType == int.class) {
+				return Integer.toString(f.getInt(args));
+			}
+			if (fieldType == String.class) {
+				return (String) f.get(args);
+			}
+			if (Enum.class.isAssignableFrom(fieldType)) {
+				Enum<?> val = (Enum<?>) f.get(args);
+				if (val != null) {
+					return val.name().toLowerCase(Locale.ROOT);
+				}
+			}
+		} catch (Exception e) {
+			// ignore
+		}
+		return null;
+	}
+
+	private static void addSpaces(StringBuilder str, int count) {
+		for (int i = 0; i < count; i++) {
+			str.append(' ');
+		}
+	}
+}

jadx-cli/src/main/java/jadx/cli/JadxCLI.java

@@ -1,68 +1,63 @@
 package jadx.cli;
 
-import jadx.api.Decompiler;
-import jadx.core.utils.ErrorsCounter;
-import jadx.core.utils.exceptions.JadxException;
-
-import java.io.File;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.JadxArgs;
+import jadx.api.JadxDecompiler;
+import jadx.api.impl.NoOpCodeCache;
+import jadx.api.impl.SimpleCodeWriter;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+import jadx.core.utils.files.FileUtils;
+
 public class JadxCLI {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxCLI.class);
 
 	public static void main(String[] args) {
+		int result = 0;
 		try {
-			JadxCLIArgs jadxArgs = new JadxCLIArgs(args);
-			checkArgs(jadxArgs);
-			processAndSave(jadxArgs);
+			result = execute(args);
+		} catch (JadxArgsValidateException e) {
+			LOG.error("Incorrect arguments: {}", e.getMessage());
+			result = 1;
 		} catch (Exception e) {
-			LOG.error(e.getMessage());
-			System.exit(1);
+			LOG.error("jadx error: {}", e.getMessage(), e);
+			result = 1;
+		} finally {
+			FileUtils.deleteTempRootDir();
+			System.exit(result);
 		}
 	}
 
-	private static void processAndSave(JadxCLIArgs jadxArgs) {
-		try {
-			Decompiler jadx = new Decompiler(jadxArgs);
-			jadx.loadFiles(jadxArgs.getInput());
-			jadx.setOutputDir(jadxArgs.getOutDir());
-			jadx.save();
-			LOG.info("done");
-		} catch (Throwable e) {
-			LOG.error("jadx error:", e);
+	public static int execute(String[] args) {
+		JadxCLIArgs jadxArgs = new JadxCLIArgs();
+		if (jadxArgs.processArgs(args)) {
+			return processAndSave(jadxArgs.toJadxArgs());
 		}
-		int errorsCount = ErrorsCounter.getErrorCount();
-		if (errorsCount != 0) {
-			ErrorsCounter.printReport();
-		}
-		System.exit(errorsCount);
+		return 0;
 	}
 
-	private static void checkArgs(JadxCLIArgs jadxArgs) throws JadxException {
-		if (jadxArgs.getInput().isEmpty()) {
-			LOG.error("Please specify input file");
-			jadxArgs.printUsage();
-			System.exit(1);
-		}
-		File outputDir = jadxArgs.getOutDir();
-		if (outputDir == null) {
-			String outDirName;
-			File file = jadxArgs.getInput().get(0);
-			String name = file.getName();
-			int pos = name.lastIndexOf('.');
-			if (pos != -1) {
-				outDirName = name.substring(0, pos);
+	private static int processAndSave(JadxArgs jadxArgs) {
+		jadxArgs.setCodeCache(new NoOpCodeCache());
+		jadxArgs.setCodeWriterProvider(SimpleCodeWriter::new);
+		try (JadxDecompiler jadx = new JadxDecompiler(jadxArgs)) {
+			jadx.load();
+			if (LogHelper.getLogLevel() == LogHelper.LogLevelEnum.QUIET) {
+				jadx.save();
 			} else {
-				outDirName = name + "-jadx-out";
+				jadx.save(500, (done, total) -> {
+					int progress = (int) (done * 100.0 / total);
+					System.out.printf("INFO  - progress: %d of %d (%d%%)\r", done, total, progress);
+				});
+			}
+			int errorsCount = jadx.getErrorsCount();
+			if (errorsCount != 0) {
+				jadx.printErrorsReport();
+				LOG.error("finished with errors, count: {}", errorsCount);
+			} else {
+				LOG.info("done");
 			}
-			LOG.info("output directory: " + outDirName);
-			outputDir = new File(outDirName);
-			jadxArgs.setOutputDir(outputDir);
-		}
-		if (outputDir.exists() && !outputDir.isDirectory()) {
-			throw new JadxException("Output directory exists as file " + outputDir);
 		}
+		return 0;
 	}
 }

jadx-cli/src/main/java/jadx/cli/JadxCLIArgs.java

@@ -1,184 +1,412 @@
 package jadx.cli;
 
-import jadx.api.IJadxArgs;
-import jadx.core.Consts;
-import jadx.core.utils.exceptions.JadxException;
-
-import java.io.File;
-import java.io.PrintStream;
-import java.lang.reflect.Field;
 import java.util.ArrayList;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.beust.jcommander.JCommander;
+import com.beust.jcommander.IStringConverter;
 import com.beust.jcommander.Parameter;
-import com.beust.jcommander.ParameterDescription;
-import com.beust.jcommander.ParameterException;
 
-public final class JadxCLIArgs implements IJadxArgs {
+import jadx.api.CommentsLevel;
+import jadx.api.JadxArgs;
+import jadx.api.JadxArgs.RenameEnum;
+import jadx.api.JadxDecompiler;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.files.FileUtils;
 
-	@Parameter(description = "<input file> (.dex, .apk or .jar)")
-	protected List<String> files;
+public class JadxCLIArgs {
 
-	@Parameter(names = {"-d", "--output-dir"}, description = "output directory")
-	protected String outDirName;
+	@Parameter(description = "<input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab)")
+	protected List<String> files = new ArrayList<>(1);
 
-	@Parameter(names = {"-j", "--threads-count"}, description = "processing threads count")
-	protected int threadsCount = Runtime.getRuntime().availableProcessors();
+	@Parameter(names = { "-d", "--output-dir" }, description = "output directory")
+	protected String outDir;
 
-	@Parameter(names = {"-f", "--fallback"}, description = "make simple dump (using goto instead of 'if', 'for', etc)", help = true)
-	protected boolean fallbackMode = false;
+	@Parameter(names = { "-ds", "--output-dir-src" }, description = "output directory for sources")
+	protected String outDirSrc;
 
-	@Parameter(names = {"--cfg"}, description = "save methods control flow graph to dot file")
+	@Parameter(names = { "-dr", "--output-dir-res" }, description = "output directory for resources")
+	protected String outDirRes;
+
+	@Parameter(names = { "-r", "--no-res" }, description = "do not decode resources")
+	protected boolean skipResources = false;
+
+	@Parameter(names = { "-s", "--no-src" }, description = "do not decompile source code")
+	protected boolean skipSources = false;
+
+	@Parameter(names = { "--single-class" }, description = "decompile a single class")
+	protected String singleClass = null;
+
+	@Parameter(names = { "--output-format" }, description = "can be 'java' or 'json'")
+	protected String outputFormat = "java";
+
+	@Parameter(names = { "-e", "--export-gradle" }, description = "save as android gradle project")
+	protected boolean exportAsGradleProject = false;
+
+	@Parameter(names = { "-j", "--threads-count" }, description = "processing threads count")
+	protected int threadsCount = JadxArgs.DEFAULT_THREADS_COUNT;
+
+	@Parameter(names = { "--show-bad-code" }, description = "show inconsistent code (incorrectly decompiled)")
+	protected boolean showInconsistentCode = false;
+
+	@Parameter(names = { "--no-imports" }, description = "disable use of imports, always write entire package name")
+	protected boolean useImports = true;
+
+	@Parameter(names = { "--no-debug-info" }, description = "disable debug info")
+	protected boolean debugInfo = true;
+
+	@Parameter(names = { "--add-debug-lines" }, description = "add comments with debug line numbers if available")
+	protected boolean addDebugLines = false;
+
+	@Parameter(names = { "--no-inline-anonymous" }, description = "disable anonymous classes inline")
+	protected boolean inlineAnonymousClasses = true;
+
+	@Parameter(names = { "--no-inline-methods" }, description = "disable methods inline")
+	protected boolean inlineMethods = true;
+
+	@Parameter(names = "--no-replace-consts", description = "don't replace constant value with matching constant field")
+	protected boolean replaceConsts = true;
+
+	@Parameter(names = { "--escape-unicode" }, description = "escape non latin characters in strings (with \\u)")
+	protected boolean escapeUnicode = false;
+
+	@Parameter(names = { "--respect-bytecode-access-modifiers" }, description = "don't change original access modifiers")
+	protected boolean respectBytecodeAccessModifiers = false;
+
+	@Parameter(names = { "--deobf" }, description = "activate deobfuscation")
+	protected boolean deobfuscationOn = false;
+
+	@Parameter(names = { "--deobf-min" }, description = "min length of name, renamed if shorter")
+	protected int deobfuscationMinLength = 3;
+
+	@Parameter(names = { "--deobf-max" }, description = "max length of name, renamed if longer")
+	protected int deobfuscationMaxLength = 64;
+
+	@Parameter(
+			names = { "--deobf-cfg-file" },
+			description = "deobfuscation map file, default: same dir and name as input file with '.jobf' extension"
+	)
+	protected String deobfuscationMapFile;
+
+	@Parameter(names = { "--deobf-rewrite-cfg" }, description = "force to ignore and overwrite deobfuscation map file")
+	protected boolean deobfuscationForceSave = false;
+
+	@Parameter(names = { "--deobf-use-sourcename" }, description = "use source file name as class name alias")
+	protected boolean deobfuscationUseSourceNameAsAlias = false;
+
+	@Parameter(names = { "--deobf-parse-kotlin-metadata" }, description = "parse kotlin metadata to class and package names")
+	protected boolean deobfuscationParseKotlinMetadata = false;
+
+	@Parameter(
+			names = { "--rename-flags" },
+			description = "fix options (comma-separated list of):"
+					+ "\n 'case' - fix case sensitivity issues (according to --fs-case-sensitive option),"
+					+ "\n 'valid' - rename java identifiers to make them valid,"
+					+ "\n 'printable' - remove non-printable chars from identifiers,"
+					+ "\nor single 'none' - to disable all renames"
+					+ "\nor single 'all' - to enable all (default)",
+			converter = RenameConverter.class
+	)
+	protected Set<RenameEnum> renameFlags = EnumSet.allOf(RenameEnum.class);
+
+	@Parameter(names = { "--fs-case-sensitive" }, description = "treat filesystem as case sensitive, false by default")
+	protected boolean fsCaseSensitive = false;
+
+	@Parameter(names = { "--cfg" }, description = "save methods control flow graph to dot file")
 	protected boolean cfgOutput = false;
 
-	@Parameter(names = {"--raw-cfg"}, description = "save methods control flow graph (use raw instructions)")
+	@Parameter(names = { "--raw-cfg" }, description = "save methods control flow graph (use raw instructions)")
 	protected boolean rawCfgOutput = false;
 
-	@Parameter(names = {"-v", "--verbose"}, description = "verbose output")
+	@Parameter(names = { "-f", "--fallback" }, description = "make simple dump (using goto instead of 'if', 'for', etc)")
+	protected boolean fallbackMode = false;
+
+	@Parameter(
+			names = { "--comments-level" },
+			description = "set code comments level, values: error, warn, info, debug, user_only, none",
+			converter = CommentsLevelConverter.class
+	)
+	protected CommentsLevel commentsLevel = CommentsLevel.INFO;
+
+	@Parameter(
+			names = { "--log-level" },
+			description = "set log level, values: quiet, progress, error, warn, info, debug",
+			converter = LogHelper.LogLevelConverter.class
+	)
+	protected LogHelper.LogLevelEnum logLevel = LogHelper.LogLevelEnum.PROGRESS;
+
+	@Parameter(names = { "-v", "--verbose" }, description = "verbose output (set --log-level to DEBUG)")
 	protected boolean verbose = false;
 
-	@Parameter(names = {"-h", "--help"}, description = "print this help", help = true)
+	@Parameter(names = { "-q", "--quiet" }, description = "turn off output (set --log-level to QUIET)")
+	protected boolean quiet = false;
+
+	@Parameter(names = { "--version" }, description = "print jadx version")
+	protected boolean printVersion = false;
+
+	@Parameter(names = { "-h", "--help" }, description = "print this help", help = true)
 	protected boolean printHelp = false;
 
-	private final List<File> input = new ArrayList<File>(1);
-	private File outputDir;
-
-	public JadxCLIArgs(String[] args) {
-		parse(args);
-		processArgs();
+	public boolean processArgs(String[] args) {
+		JCommanderWrapper<JadxCLIArgs> jcw = new JCommanderWrapper<>(this);
+		return jcw.parse(args) && process(jcw);
 	}
 
-	private void parse(String[] args) {
-		try {
-			new JCommander(this, args);
-		} catch (ParameterException e) {
-			System.err.println("Arguments parse error: " + e.getMessage());
-			printUsage();
-			System.exit(1);
+	/**
+	 * Set values only for options provided in cmd.
+	 * Used to merge saved options and options passed in command line.
+	 */
+	public boolean overrideProvided(String[] args) {
+		JCommanderWrapper<JadxCLIArgs> jcw = new JCommanderWrapper<>(newInstance());
+		if (!jcw.parse(args)) {
+			return false;
 		}
+		jcw.overrideProvided(this);
+		return process(jcw);
 	}
 
-	public void processArgs() {
-		if (isPrintHelp()) {
-			printUsage();
-			System.exit(0);
+	protected JadxCLIArgs newInstance() {
+		return new JadxCLIArgs();
+	}
+
+	private boolean process(JCommanderWrapper<JadxCLIArgs> jcw) {
+		if (printHelp) {
+			jcw.printUsage();
+			return false;
+		}
+		if (printVersion) {
+			System.out.println(JadxDecompiler.getVersion());
+			return false;
 		}
 		try {
-			if (threadsCount <= 0)
-				throw new JadxException("Threads count must be positive");
-
-			if (files != null) {
-				for (String fileName : files) {
-					File file = new File(fileName);
-					if (file.exists())
-						input.add(file);
-					else
-						throw new JadxException("File not found: " + file);
-				}
-			}
-
-			if (input.size() > 1)
-				throw new JadxException("Only one input file is supported");
-
-			if (outDirName != null)
-				outputDir = new File(outDirName);
-
-			if (isVerbose()) {
-				ch.qos.logback.classic.Logger rootLogger =
-						(ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
-				rootLogger.setLevel(ch.qos.logback.classic.Level.DEBUG);
+			if (threadsCount <= 0) {
+				throw new JadxException("Threads count must be positive, got: " + threadsCount);
 			}
+			LogHelper.setLogLevelFromArgs(this);
 		} catch (JadxException e) {
 			System.err.println("ERROR: " + e.getMessage());
-			printUsage();
-			System.exit(1);
+			jcw.printUsage();
+			return false;
 		}
+		return true;
 	}
 
-	public void printUsage() {
-		JCommander jc = new JCommander(this);
-		// print usage in not sorted fields order (by default its sorted by description)
-		PrintStream out = System.out;
-		out.println();
-		out.println("jadx - dex to java decompiler, version: " + Consts.JADX_VERSION);
-		out.println();
-		out.println("usage: jadx [options] " + jc.getMainParameterDescription());
-		out.println("options:");
-
-		List<ParameterDescription> params = jc.getParameters();
-
-		int maxNamesLen = 0;
-		for (ParameterDescription p : params) {
-			int len = p.getNames().length();
-			if (len > maxNamesLen)
-				maxNamesLen = len;
+	public JadxArgs toJadxArgs() {
+		JadxArgs args = new JadxArgs();
+		args.setInputFiles(files.stream().map(FileUtils::toFile).collect(Collectors.toList()));
+		args.setOutDir(FileUtils.toFile(outDir));
+		args.setOutDirSrc(FileUtils.toFile(outDirSrc));
+		args.setOutDirRes(FileUtils.toFile(outDirRes));
+		args.setOutputFormat(JadxArgs.OutputFormatEnum.valueOf(outputFormat.toUpperCase()));
+		args.setThreadsCount(threadsCount);
+		args.setSkipSources(skipSources);
+		if (singleClass != null) {
+			args.setClassFilter(className -> singleClass.equals(className));
 		}
-
-		Field[] fields = this.getClass().getDeclaredFields();
-		for (Field f : fields) {
-			for (ParameterDescription p : params) {
-				String name = f.getName();
-				if (name.equals(p.getParameterized().getName())) {
-					StringBuilder opt = new StringBuilder();
-					opt.append(' ').append(p.getNames());
-					addSpaces(opt, maxNamesLen - opt.length() + 2);
-					opt.append("- ").append(p.getDescription());
-					out.println(opt.toString());
-					break;
-				}
-			}
-		}
-		out.println("Example:");
-		out.println(" jadx -d out classes.dex");
+		args.setSkipResources(skipResources);
+		args.setFallbackMode(fallbackMode);
+		args.setShowInconsistentCode(showInconsistentCode);
+		args.setCfgOutput(cfgOutput);
+		args.setRawCFGOutput(rawCfgOutput);
+		args.setReplaceConsts(replaceConsts);
+		args.setDeobfuscationOn(deobfuscationOn);
+		args.setDeobfuscationMapFile(FileUtils.toFile(deobfuscationMapFile));
+		args.setDeobfuscationForceSave(deobfuscationForceSave);
+		args.setDeobfuscationMinLength(deobfuscationMinLength);
+		args.setDeobfuscationMaxLength(deobfuscationMaxLength);
+		args.setUseSourceNameAsClassAlias(deobfuscationUseSourceNameAsAlias);
+		args.setParseKotlinMetadata(deobfuscationParseKotlinMetadata);
+		args.setEscapeUnicode(escapeUnicode);
+		args.setRespectBytecodeAccModifiers(respectBytecodeAccessModifiers);
+		args.setExportAsGradleProject(exportAsGradleProject);
+		args.setUseImports(useImports);
+		args.setDebugInfo(debugInfo);
+		args.setInsertDebugLines(addDebugLines);
+		args.setInlineAnonymousClasses(inlineAnonymousClasses);
+		args.setInlineMethods(inlineMethods);
+		args.setRenameFlags(renameFlags);
+		args.setFsCaseSensitive(fsCaseSensitive);
+		args.setCommentsLevel(commentsLevel);
+		return args;
 	}
 
-	private static void addSpaces(StringBuilder str, int count) {
-		for (int i = 0; i < count; i++)
-			str.append(' ');
+	public List<String> getFiles() {
+		return files;
 	}
 
-	public List<File> getInput() {
-		return input;
+	public String getOutDir() {
+		return outDir;
 	}
 
-	public File getOutDir() {
-		return outputDir;
+	public String getOutDirSrc() {
+		return outDirSrc;
 	}
 
-	public void setOutputDir(File outputDir) {
-		this.outputDir = outputDir;
+	public String getOutDirRes() {
+		return outDirRes;
 	}
 
-	public boolean isPrintHelp() {
-		return printHelp;
+	public boolean isSkipResources() {
+		return skipResources;
+	}
+
+	public boolean isSkipSources() {
+		return skipSources;
 	}
 
-	@Override
 	public int getThreadsCount() {
 		return threadsCount;
 	}
 
-	@Override
-	public boolean isCFGOutput() {
-		return cfgOutput;
-	}
-
-	@Override
-	public boolean isRawCFGOutput() {
-		return rawCfgOutput;
-	}
-
-	@Override
 	public boolean isFallbackMode() {
 		return fallbackMode;
 	}
 
-	@Override
-	public boolean isVerbose() {
-		return verbose;
+	public boolean isShowInconsistentCode() {
+		return showInconsistentCode;
+	}
+
+	public boolean isUseImports() {
+		return useImports;
+	}
+
+	public boolean isDebugInfo() {
+		return debugInfo;
+	}
+
+	public boolean isAddDebugLines() {
+		return addDebugLines;
+	}
+
+	public boolean isInlineAnonymousClasses() {
+		return inlineAnonymousClasses;
+	}
+
+	public boolean isInlineMethods() {
+		return inlineMethods;
+	}
+
+	public boolean isDeobfuscationOn() {
+		return deobfuscationOn;
+	}
+
+	public int getDeobfuscationMinLength() {
+		return deobfuscationMinLength;
+	}
+
+	public int getDeobfuscationMaxLength() {
+		return deobfuscationMaxLength;
+	}
+
+	public String getDeobfuscationMapFile() {
+		return deobfuscationMapFile;
+	}
+
+	public boolean isDeobfuscationForceSave() {
+		return deobfuscationForceSave;
+	}
+
+	public boolean isDeobfuscationUseSourceNameAsAlias() {
+		return deobfuscationUseSourceNameAsAlias;
+	}
+
+	public boolean isDeobfuscationParseKotlinMetadata() {
+		return deobfuscationParseKotlinMetadata;
+	}
+
+	public boolean isEscapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public boolean isRawCfgOutput() {
+		return rawCfgOutput;
+	}
+
+	public boolean isReplaceConsts() {
+		return replaceConsts;
+	}
+
+	public boolean isRespectBytecodeAccessModifiers() {
+		return respectBytecodeAccessModifiers;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
+
+	public boolean isRenameCaseSensitive() {
+		return renameFlags.contains(RenameEnum.CASE);
+	}
+
+	public boolean isRenameValid() {
+		return renameFlags.contains(RenameEnum.VALID);
+	}
+
+	public boolean isRenamePrintable() {
+		return renameFlags.contains(RenameEnum.PRINTABLE);
+	}
+
+	public boolean isFsCaseSensitive() {
+		return fsCaseSensitive;
+	}
+
+	public CommentsLevel getCommentsLevel() {
+		return commentsLevel;
+	}
+
+	static class RenameConverter implements IStringConverter<Set<RenameEnum>> {
+		private final String paramName;
+
+		RenameConverter(String paramName) {
+			this.paramName = paramName;
+		}
+
+		@Override
+		public Set<RenameEnum> convert(String value) {
+			if (value.equalsIgnoreCase("NONE")) {
+				return EnumSet.noneOf(RenameEnum.class);
+			}
+			if (value.equalsIgnoreCase("ALL")) {
+				return EnumSet.allOf(RenameEnum.class);
+			}
+			Set<RenameEnum> set = EnumSet.noneOf(RenameEnum.class);
+			for (String s : value.split(",")) {
+				try {
+					set.add(RenameEnum.valueOf(s.trim().toUpperCase(Locale.ROOT)));
+				} catch (IllegalArgumentException e) {
+					throw new IllegalArgumentException(
+							'\'' + s + "' is unknown for parameter " + paramName
+									+ ", possible values are " + enumValuesString(RenameEnum.values()));
+				}
+			}
+			return set;
+		}
+	}
+
+	public static class CommentsLevelConverter implements IStringConverter<CommentsLevel> {
+		@Override
+		public CommentsLevel convert(String value) {
+			try {
+				return CommentsLevel.valueOf(value.toUpperCase());
+			} catch (Exception e) {
+				throw new IllegalArgumentException(
+						'\'' + value + "' is unknown comments level, possible values are: "
+								+ JadxCLIArgs.enumValuesString(CommentsLevel.values()));
+			}
+		}
+	}
+
+	public static String enumValuesString(Enum<?>[] values) {
+		return Stream.of(values)
+				.map(v -> v.name().toLowerCase(Locale.ROOT))
+				.collect(Collectors.joining(", "));
 	}
 }

jadx-cli/src/main/java/jadx/cli/LogHelper.java

@@ -0,0 +1,107 @@
+package jadx.cli;
+
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.LoggerFactory;
+
+import com.beust.jcommander.IStringConverter;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+
+import jadx.api.JadxDecompiler;
+
+public class LogHelper {
+	private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(LogHelper.class);
+
+	public enum LogLevelEnum {
+		QUIET(Level.OFF),
+		PROGRESS(Level.OFF),
+		ERROR(Level.ERROR),
+		WARN(Level.WARN),
+		INFO(Level.INFO),
+		DEBUG(Level.DEBUG);
+
+		private final Level level;
+
+		LogLevelEnum(Level level) {
+			this.level = level;
+		}
+
+		public Level getLevel() {
+			return level;
+		}
+	}
+
+	private static LogLevelEnum logLevelValue;
+
+	public static void setLogLevelFromArgs(JadxCLIArgs args) {
+		if (isCustomLogConfig()) {
+			return;
+		}
+		LogLevelEnum logLevel = args.logLevel;
+		if (args.quiet) {
+			logLevel = LogLevelEnum.QUIET;
+		} else if (args.verbose) {
+			logLevel = LogLevelEnum.DEBUG;
+		}
+
+		applyLogLevel(logLevel);
+	}
+
+	public static void applyLogLevel(LogLevelEnum logLevel) {
+		logLevelValue = logLevel;
+
+		Logger rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+		rootLogger.setLevel(logLevel.getLevel());
+
+		if (logLevel != LogLevelEnum.QUIET) {
+			// show progress for all levels except quiet
+			setLevelForClass(JadxCLI.class, Level.INFO);
+			setLevelForClass(JadxDecompiler.class, Level.INFO);
+		}
+	}
+
+	@Nullable
+	public static LogLevelEnum getLogLevel() {
+		return logLevelValue;
+	}
+
+	public static void setLevelForClass(Class<?> cls, Level level) {
+		((Logger) LoggerFactory.getLogger(cls)).setLevel(level);
+	}
+
+	public static void setLevelForPackage(String pkgName, Level level) {
+		((Logger) LoggerFactory.getLogger(pkgName)).setLevel(level);
+	}
+
+	/**
+	 * Try to detect if user provide custom logback config via -Dlogback.configurationFile=
+	 */
+	private static boolean isCustomLogConfig() {
+		try {
+			String logbackConfig = System.getProperty("logback.configurationFile");
+			if (logbackConfig == null) {
+				return false;
+			}
+			LOG.debug("Use custom log config: {}", logbackConfig);
+			return true;
+		} catch (Exception e) {
+			LOG.error("Failed to detect custom log config", e);
+		}
+		return false;
+	}
+
+	public static class LogLevelConverter implements IStringConverter<LogLevelEnum> {
+
+		@Override
+		public LogLevelEnum convert(String value) {
+			try {
+				return LogLevelEnum.valueOf(value.toUpperCase());
+			} catch (Exception e) {
+				throw new IllegalArgumentException(
+						'\'' + value + "' is unknown log level, possible values are "
+								+ JadxCLIArgs.enumValuesString(LogLevelEnum.values()));
+			}
+		}
+	}
+}

jadx-cli/src/main/java/jadx/cli/clst/ConvertToClsSet.java

@@ -0,0 +1,66 @@
+package jadx.cli.clst;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.api.plugins.JadxPluginManager;
+import jadx.api.plugins.input.JadxInputPlugin;
+import jadx.api.plugins.input.data.ILoadResult;
+import jadx.core.clsp.ClsSet;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.dex.visitors.SignatureProcessor;
+
+/**
+ * Utility class for convert dex or jar to jadx classes set (.jcst)
+ */
+public class ConvertToClsSet {
+	private static final Logger LOG = LoggerFactory.getLogger(ConvertToClsSet.class);
+
+	public static void usage() {
+		LOG.info("<output .jcst or .jar file> <several input dex or jar files> ");
+	}
+
+	public static void main(String[] args) throws Exception {
+		if (args.length < 2) {
+			usage();
+			System.exit(1);
+		}
+		List<Path> inputPaths = Stream.of(args).map(Paths::get).collect(Collectors.toList());
+		Path output = inputPaths.remove(0);
+
+		JadxPluginManager pluginManager = new JadxPluginManager();
+		List<ILoadResult> loadedInputs = new ArrayList<>();
+		for (JadxInputPlugin inputPlugin : pluginManager.getInputPlugins()) {
+			loadedInputs.add(inputPlugin.loadFiles(inputPaths));
+		}
+
+		JadxArgs jadxArgs = new JadxArgs();
+		jadxArgs.setRenameFlags(EnumSet.noneOf(JadxArgs.RenameEnum.class));
+		RootNode root = new RootNode(jadxArgs);
+		root.loadClasses(loadedInputs);
+
+		// from pre-decompilation stage run only SignatureProcessor
+		SignatureProcessor signatureProcessor = new SignatureProcessor();
+		signatureProcessor.init(root);
+		for (ClassNode classNode : root.getClasses()) {
+			signatureProcessor.visit(classNode);
+		}
+
+		ClsSet set = new ClsSet(root);
+		set.loadFrom(root);
+		set.save(output);
+
+		LOG.info("Output: {}", output);
+		LOG.info("done");
+	}
+}

jadx-cli/src/main/java/jadx/cli/tools/ConvertArscFile.java

@@ -0,0 +1,98 @@
+package jadx.cli.tools;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.android.TextResMapFile;
+import jadx.core.xmlgen.ResTableParser;
+
+/**
+ * Utility class for convert '.arsc' to simple text file with mapping id to resource name
+ */
+public class ConvertArscFile {
+	private static final Logger LOG = LoggerFactory.getLogger(ConvertArscFile.class);
+	private static int rewritesCount;
+
+	public static void usage() {
+		LOG.info("<res-map file> <input .arsc files>");
+		LOG.info("");
+		LOG.info("Note: If res-map already exists - it will be merged and updated");
+	}
+
+	public static void main(String[] args) throws IOException {
+		if (args.length < 2) {
+			usage();
+			System.exit(1);
+		}
+		List<Path> inputPaths = Stream.of(args).map(Paths::get).collect(Collectors.toList());
+		Path resMapFile = inputPaths.remove(0);
+		Map<Integer, String> resMap;
+		if (Files.isReadable(resMapFile)) {
+			resMap = TextResMapFile.read(resMapFile);
+		} else {
+			resMap = new HashMap<>();
+		}
+		LOG.info("Input entries count: {}", resMap.size());
+
+		RootNode root = new RootNode(new JadxArgs()); // not really needed
+		rewritesCount = 0;
+		for (Path resFile : inputPaths) {
+			LOG.info("Processing {}", resFile);
+			ResTableParser resTableParser = new ResTableParser(root, true);
+			if (resFile.getFileName().toString().endsWith(".jar")) {
+				// Load resources.arsc from android.jar
+				try (ZipFile zip = new ZipFile(resFile.toFile())) {
+					ZipEntry entry = zip.getEntry("resources.arsc");
+					if (entry == null) {
+						LOG.error("Failed to load \"resources.arsc\" from {}", resFile);
+						continue;
+					}
+					try (InputStream inputStream = zip.getInputStream(entry)) {
+						resTableParser.decode(inputStream);
+					}
+				}
+			} else {
+				// Load resources.arsc from extracted file
+				try (InputStream inputStream = new BufferedInputStream(Files.newInputStream(resFile))) {
+					resTableParser.decode(inputStream);
+				}
+			}
+			Map<Integer, String> singleResMap = resTableParser.getResStorage().getResourcesNames();
+			mergeResMaps(resMap, singleResMap);
+			LOG.info("{} entries count: {}, after merge: {}", resFile.getFileName(), singleResMap.size(), resMap.size());
+		}
+		LOG.info("Output entries count: {}", resMap.size());
+		LOG.info("Total rewrites count: {}", rewritesCount);
+		TextResMapFile.write(resMapFile, resMap);
+		LOG.info("Result file size: {} B", resMapFile.toFile().length());
+		LOG.info("done");
+	}
+
+	private static void mergeResMaps(Map<Integer, String> mainResMap, Map<Integer, String> newResMap) {
+		for (Map.Entry<Integer, String> entry : newResMap.entrySet()) {
+			Integer id = entry.getKey();
+			String name = entry.getValue();
+			String prevName = mainResMap.put(id, name);
+			if (prevName != null && !name.equals(prevName)) {
+				LOG.debug("Rewrite id: {} from: '{}' to: '{}'", Integer.toHexString(id), prevName, name);
+				rewritesCount++;
+			}
+		}
+	}
+}

jadx-cli/src/main/resources/logback.xml

@@ -1,13 +1,11 @@
 <configuration>
+	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+		<encoder>
+			<pattern>%-5level - %msg%n</pattern>
+		</encoder>
+	</appender>
 
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%-5level - %msg%n</pattern>
-        </encoder>
-    </appender>
-
-    <root level="INFO">
-        <appender-ref ref="STDOUT"/>
-    </root>
-
+	<root level="INFO">
+		<appender-ref ref="STDOUT"/>
+	</root>
 </configuration>

jadx-cli/src/test/java/jadx/cli/JadxCLIArgsTest.java

@@ -0,0 +1,67 @@
+package jadx.cli;
+
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+public class JadxCLIArgsTest {
+
+	private static final Logger LOG = LoggerFactory.getLogger(JadxCLIArgsTest.class);
+
+	@Test
+	public void testInvertedBooleanOption() {
+		assertThat(parse("--no-replace-consts").isReplaceConsts(), is(false));
+		assertThat(parse("").isReplaceConsts(), is(true));
+	}
+
+	@Test
+	public void testEscapeUnicodeOption() {
+		assertThat(parse("--escape-unicode").isEscapeUnicode(), is(true));
+		assertThat(parse("").isEscapeUnicode(), is(false));
+	}
+
+	@Test
+	public void testSrcOption() {
+		assertThat(parse("--no-src").isSkipSources(), is(true));
+		assertThat(parse("-s").isSkipSources(), is(true));
+		assertThat(parse("").isSkipSources(), is(false));
+	}
+
+	@Test
+	public void testOptionsOverride() {
+		assertThat(override(new JadxCLIArgs(), "--no-imports").isUseImports(), is(false));
+		assertThat(override(new JadxCLIArgs(), "--no-debug-info").isDebugInfo(), is(false));
+		assertThat(override(new JadxCLIArgs(), "").isUseImports(), is(true));
+
+		JadxCLIArgs args = new JadxCLIArgs();
+		args.useImports = false;
+		assertThat(override(args, "--no-imports").isUseImports(), is(false));
+		args.debugInfo = false;
+		assertThat(override(args, "--no-debug-info").isDebugInfo(), is(false));
+
+		args = new JadxCLIArgs();
+		args.useImports = false;
+		assertThat(override(args, "").isUseImports(), is(false));
+	}
+
+	private JadxCLIArgs parse(String... args) {
+		return parse(new JadxCLIArgs(), args);
+	}
+
+	private JadxCLIArgs parse(JadxCLIArgs jadxArgs, String... args) {
+		boolean res = jadxArgs.processArgs(args);
+		assertThat(res, is(true));
+		LOG.info("Jadx args: {}", jadxArgs.toJadxArgs());
+		return jadxArgs;
+	}
+
+	private JadxCLIArgs override(JadxCLIArgs jadxArgs, String... args) {
+		boolean res = jadxArgs.overrideProvided(args);
+		assertThat(res, is(true));
+		LOG.info("Jadx args: {}", jadxArgs.toJadxArgs());
+		return jadxArgs;
+	}
+}

jadx-cli/src/test/java/jadx/cli/RenameConverterTest.java

@@ -0,0 +1,48 @@
+package jadx.cli;
+
+import java.util.Set;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import jadx.api.JadxArgs.RenameEnum;
+import jadx.cli.JadxCLIArgs.RenameConverter;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class RenameConverterTest {
+
+	private RenameConverter converter;
+
+	@BeforeEach
+	public void init() {
+		converter = new RenameConverter("someParam");
+	}
+
+	@Test
+	public void all() {
+		Set<RenameEnum> set = converter.convert("all");
+		assertEquals(3, set.size());
+		assertTrue(set.contains(RenameEnum.CASE));
+		assertTrue(set.contains(RenameEnum.VALID));
+		assertTrue(set.contains(RenameEnum.PRINTABLE));
+	}
+
+	@Test
+	public void none() {
+		Set<RenameEnum> set = converter.convert("none");
+		assertTrue(set.isEmpty());
+	}
+
+	@Test
+	public void wrong() {
+		IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class,
+				() -> converter.convert("wrong"),
+				"Expected convert() to throw, but it didn't");
+
+		assertEquals("'wrong' is unknown for parameter someParam, possible values are case, valid, printable",
+				thrown.getMessage());
+	}
+}

jadx-cli/src/test/java/jadx/cli/TestInput.java

@@ -0,0 +1,96 @@
+package jadx.cli;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.core.utils.files.FileUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestInput {
+	private static final Logger LOG = LoggerFactory.getLogger(TestInput.class);
+
+	@Test
+	public void testDexInput() throws Exception {
+		decompile("dex", "samples/hello.dex");
+	}
+
+	@Test
+	public void testSmaliInput() throws Exception {
+		decompile("smali", "samples/HelloWorld.smali");
+	}
+
+	@Test
+	public void testClassInput() throws Exception {
+		decompile("class", "samples/HelloWorld.class");
+	}
+
+	@Test
+	public void testMultipleInput() throws Exception {
+		decompile("multi", "samples/hello.dex", "samples/HelloWorld.smali");
+	}
+
+	private void decompile(String tmpDirName, String... inputSamples) throws URISyntaxException, IOException {
+		List<String> args = new ArrayList<>();
+		Path tempDir = FileUtils.createTempDir(tmpDirName);
+		args.add("-v");
+		args.add("-d");
+		args.add(tempDir.toAbsolutePath().toString());
+
+		for (String inputSample : inputSamples) {
+			URL resource = getClass().getClassLoader().getResource(inputSample);
+			assertThat(resource).isNotNull();
+			String sampleFile = resource.toURI().getRawPath();
+			args.add(sampleFile);
+		}
+
+		int result = JadxCLI.execute(args.toArray(new String[0]));
+		assertThat(result).isEqualTo(0);
+		List<Path> resultJavaFiles = collectJavaFilesInDir(tempDir);
+		assertThat(resultJavaFiles).isNotEmpty();
+
+		// do not copy input files as resources
+		PathMatcher logAllFiles = path -> {
+			LOG.debug("File in result dir: {}", path);
+			return true;
+		};
+		for (Path path : collectFilesInDir(tempDir, logAllFiles)) {
+			for (String inputSample : inputSamples) {
+				assertThat(path.toAbsolutePath().toString()).doesNotContain(inputSample);
+			}
+		}
+	}
+
+	private static List<Path> collectJavaFilesInDir(Path dir) throws IOException {
+		PathMatcher javaMatcher = dir.getFileSystem().getPathMatcher("glob:**.java");
+		return collectFilesInDir(dir, javaMatcher);
+	}
+
+	private static List<Path> collectFilesInDir(Path dir, PathMatcher matcher) throws IOException {
+		try (Stream<Path> pathStream = Files.walk(dir)) {
+			return pathStream
+					.filter(p -> Files.isRegularFile(p, LinkOption.NOFOLLOW_LINKS))
+					.filter(matcher::matches)
+					.collect(Collectors.toList());
+		}
+	}
+
+	@AfterAll
+	public static void cleanup() {
+		FileUtils.clearTempRootDir();
+	}
+}

jadx-cli/src/test/resources/samples/HelloWorld.smali

@@ -0,0 +1,26 @@
+.class Lsmali/HelloWorld;
+.super Ljava/lang/Object;
+.source "HelloWorld.java"
+
+.method constructor <init>()V
+    .registers 1
+
+    .line 1
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    return-void
+.end method
+
+.method public static main([Ljava/lang/String;)V
+    .registers 2
+
+    .line 3
+    sget-object p0, Ljava/lang/System;->out:Ljava/io/PrintStream;
+
+    const-string v0, "Hello, World"
+
+    invoke-virtual {p0, v0}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
+
+    .line 4
+    return-void
+.end method

jadx-core/build.gradle

@@ -1,9 +1,28 @@
-ext.jadxClasspath = 'clsp-data/android-4.3.jar'
-
-dependencies {
-    compile 'com.google.android.tools:dx:1.7'
-    compile 'ch.qos.logback:logback-classic:1.0.13'
-
-    runtime files(jadxClasspath)
+plugins {
+	id 'java-library'
 }
 
+dependencies {
+	api(project(':jadx-plugins:jadx-plugins-api'))
+
+	implementation 'com.google.code.gson:gson:2.8.9'
+	implementation 'com.android.tools.build:aapt2-proto:4.2.1-7147631'
+	constraints {
+		// Force protobuf version to prevent Java-7 issue
+		implementation 'com.google.protobuf:protobuf-java:3.11.4'
+	}
+
+	testImplementation 'org.apache.commons:commons-lang3:3.12.0'
+
+	testRuntimeOnly(project(':jadx-plugins:jadx-dex-input'))
+	testRuntimeOnly(project(':jadx-plugins:jadx-smali-input'))
+	testRuntimeOnly(project(':jadx-plugins:jadx-java-convert'))
+	testRuntimeOnly(project(':jadx-plugins:jadx-java-input'))
+	testRuntimeOnly(project(':jadx-plugins:jadx-raung-input'))
+
+	testImplementation('tools.profiler:async-profiler:1.8.3')
+}
+
+test {
+	exclude '**/tmp/*'
+}

jadx-core/src/main/java/jadx/api/CodePosition.java

@@ -0,0 +1,65 @@
+package jadx.api;
+
+public final class CodePosition {
+
+	private final int line;
+	private final int offset;
+	private final int pos;
+
+	public CodePosition(int line, int offset, int pos) {
+		this.line = line;
+		this.offset = offset;
+		this.pos = pos;
+	}
+
+	public CodePosition(int line) {
+		this(line, 0, -1);
+	}
+
+	@Deprecated
+	public CodePosition(int line, int offset) {
+		this(line, offset, -1);
+	}
+
+	public int getPos() {
+		return pos;
+	}
+
+	public int getLine() {
+		return line;
+	}
+
+	public int getOffset() {
+		return offset;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
+		CodePosition that = (CodePosition) o;
+		return line == that.line && offset == that.offset;
+	}
+
+	@Override
+	public int hashCode() {
+		return line + 31 * offset;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		sb.append(line);
+		if (offset != 0) {
+			sb.append(':').append(offset);
+		}
+		if (pos > 0) {
+			sb.append('@').append(pos);
+		}
+		return sb.toString();
+	}
+}

jadx-core/src/main/java/jadx/api/CommentsLevel.java

@@ -0,0 +1,14 @@
+package jadx.api;
+
+public enum CommentsLevel {
+	NONE,
+	USER_ONLY,
+	ERROR,
+	WARN,
+	INFO,
+	DEBUG;
+
+	public boolean filter(CommentsLevel limit) {
+		return this.ordinal() <= limit.ordinal();
+	}
+}

jadx-core/src/main/java/jadx/api/Decompiler.java

@@ -1,198 +0,0 @@
-package jadx.api;
-
-import jadx.core.Jadx;
-import jadx.core.ProcessClass;
-import jadx.core.dex.info.ClassInfo;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.RootNode;
-import jadx.core.dex.visitors.IDexTreeVisitor;
-import jadx.core.dex.visitors.SaveCode;
-import jadx.core.utils.ErrorsCounter;
-import jadx.core.utils.exceptions.CodegenException;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-import jadx.core.utils.files.InputFile;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Jadx API usage example:
- * <pre><code>
- *  Decompiler jadx = new Decompiler();
- *  jadx.loadFile(new File("classes.dex"));
- *  jadx.setOutputDir(new File("out"));
- *  jadx.save();
- * </code></pre>
- * <p/>
- * Instead of 'save()' you can get list of decompiled classes:
- * <pre><code>
- *  for(JavaClass cls : jadx.getClasses()) {
- *      System.out.println(cls.getCode());
- *  }
- * </code></pre>
- */
-public final class Decompiler {
-	private static final Logger LOG = LoggerFactory.getLogger(Decompiler.class);
-
-	private final IJadxArgs args;
-	private final List<InputFile> inputFiles = new ArrayList<InputFile>();
-
-	private File outDir;
-
-	private RootNode root;
-	private List<IDexTreeVisitor> passes;
-
-	public Decompiler() {
-		this.args = new DefaultJadxArgs();
-		init();
-	}
-
-	public Decompiler(IJadxArgs jadxArgs) {
-		this.args = jadxArgs;
-		init();
-	}
-
-	public void setOutputDir(File outDir) {
-		this.outDir = outDir;
-		init();
-	}
-
-	void init() {
-		if (outDir == null) {
-			outDir = new File("jadx-output");
-		}
-		this.passes = Jadx.getPassesList(args, outDir);
-	}
-
-	public void loadFile(File file) throws IOException, DecodeException {
-		loadFiles(Arrays.asList(file));
-	}
-
-	public void loadFiles(List<File> files) throws IOException, DecodeException {
-		if (files.isEmpty()) {
-			throw new JadxRuntimeException("Empty file list");
-		}
-		inputFiles.clear();
-		for (File file : files) {
-			inputFiles.add(new InputFile(file));
-		}
-		parse();
-	}
-
-	public void save() {
-		try {
-			ExecutorService ex = getSaveExecutor();
-			ex.awaitTermination(1, TimeUnit.DAYS);
-		} catch (InterruptedException e) {
-			LOG.error("Save interrupted", e);
-		}
-	}
-
-	public ThreadPoolExecutor getSaveExecutor() {
-		if (root == null) {
-			throw new JadxRuntimeException("No loaded files");
-		}
-		int threadsCount = args.getThreadsCount();
-		LOG.debug("processing threads count: {}", threadsCount);
-
-		ArrayList<IDexTreeVisitor> passList = new ArrayList<IDexTreeVisitor>(passes);
-		SaveCode savePass = new SaveCode(outDir, args);
-		passList.add(savePass);
-
-		LOG.info("processing ...");
-		ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(threadsCount);
-		for (ClassNode cls : root.getClasses(false)) {
-			if (cls.getCode() == null) {
-				ProcessClass job = new ProcessClass(cls, passList);
-				executor.execute(job);
-			} else {
-				try {
-					savePass.visit(cls);
-				} catch (CodegenException e) {
-					LOG.error("Can't save class {}", cls, e);
-				}
-			}
-		}
-		executor.shutdown();
-		return executor;
-	}
-
-	public List<JavaClass> getClasses() {
-		List<ClassNode> classNodeList = root.getClasses(false);
-		List<JavaClass> classes = new ArrayList<JavaClass>(classNodeList.size());
-		for (ClassNode classNode : classNodeList) {
-			classes.add(new JavaClass(this, classNode));
-		}
-		return Collections.unmodifiableList(classes);
-	}
-
-	public List<JavaPackage> getPackages() {
-		List<JavaClass> classes = getClasses();
-		Map<String, List<JavaClass>> map = new HashMap<String, List<JavaClass>>();
-		for (JavaClass javaClass : classes) {
-			String pkg = javaClass.getPackage();
-			List<JavaClass> clsList = map.get(pkg);
-			if (clsList == null) {
-				clsList = new ArrayList<JavaClass>();
-				map.put(pkg, clsList);
-			}
-			clsList.add(javaClass);
-		}
-		List<JavaPackage> packages = new ArrayList<JavaPackage>(map.size());
-		for (Map.Entry<String, List<JavaClass>> entry : map.entrySet()) {
-			packages.add(new JavaPackage(entry.getKey(), entry.getValue()));
-		}
-		Collections.sort(packages);
-		for (JavaPackage pkg : packages) {
-			Collections.sort(pkg.getClasses(), new Comparator<JavaClass>() {
-				@Override
-				public int compare(JavaClass o1, JavaClass o2) {
-					return o1.getShortName().compareTo(o2.getShortName());
-				}
-			});
-		}
-		return Collections.unmodifiableList(packages);
-	}
-
-	public int getErrorsCount() {
-		return ErrorsCounter.getErrorCount();
-	}
-
-	void parse() throws DecodeException {
-		ClassInfo.clearCache();
-		ErrorsCounter.reset();
-
-		root = new RootNode();
-		LOG.info("loading ...");
-		root.load(inputFiles);
-	}
-
-	void processClass(ClassNode cls) {
-		try {
-			ProcessClass job = new ProcessClass(cls, passes);
-			LOG.info("processing class {} ...", cls);
-			job.run();
-		} catch (Throwable e) {
-			LOG.error("Process class error", e);
-		}
-	}
-
-	RootNode getRoot() {
-		return root;
-	}
-}

jadx-core/src/main/java/jadx/api/DefaultJadxArgs.java

@@ -1,29 +0,0 @@
-package jadx.api;
-
-public class DefaultJadxArgs implements IJadxArgs {
-
-	@Override
-	public int getThreadsCount() {
-		return Runtime.getRuntime().availableProcessors();
-	}
-
-	@Override
-	public boolean isCFGOutput() {
-		return false;
-	}
-
-	@Override
-	public boolean isRawCFGOutput() {
-		return false;
-	}
-
-	@Override
-	public boolean isFallbackMode() {
-		return false;
-	}
-
-	@Override
-	public boolean isVerbose() {
-		return false;
-	}
-}

jadx-core/src/main/java/jadx/api/ICodeCache.java

@@ -0,0 +1,13 @@
+package jadx.api;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface ICodeCache {
+
+	void add(String clsFullName, ICodeInfo codeInfo);
+
+	void remove(String clsFullName);
+
+	@Nullable
+	ICodeInfo get(String clsFullName);
+}

jadx-core/src/main/java/jadx/api/ICodeInfo.java

@@ -0,0 +1,16 @@
+package jadx.api;
+
+import java.util.Map;
+
+import jadx.api.impl.SimpleCodeInfo;
+
+public interface ICodeInfo {
+
+	ICodeInfo EMPTY = new SimpleCodeInfo("");
+
+	String getCodeStr();
+
+	Map<Integer, Integer> getLineMapping();
+
+	Map<CodePosition, Object> getAnnotations();
+}

jadx-core/src/main/java/jadx/api/ICodeWriter.java

@@ -0,0 +1,60 @@
+package jadx.api;
+
+import java.util.Map;
+
+import jadx.core.dex.attributes.ILineAttributeNode;
+
+public interface ICodeWriter {
+	String NL = System.getProperty("line.separator");
+	String INDENT_STR = "    ";
+
+	boolean isMetadataSupported();
+
+	ICodeWriter startLine();
+
+	ICodeWriter startLine(char c);
+
+	ICodeWriter startLine(String str);
+
+	ICodeWriter startLineWithNum(int sourceLine);
+
+	ICodeWriter addMultiLine(String str);
+
+	ICodeWriter add(String str);
+
+	ICodeWriter add(char c);
+
+	ICodeWriter add(ICodeWriter code);
+
+	ICodeWriter newLine();
+
+	ICodeWriter addIndent();
+
+	void incIndent();
+
+	void decIndent();
+
+	int getIndent();
+
+	void setIndent(int indent);
+
+	int getLine();
+
+	void attachDefinition(ILineAttributeNode obj);
+
+	void attachAnnotation(Object obj);
+
+	void attachLineAnnotation(Object obj);
+
+	void attachSourceLine(int sourceLine);
+
+	ICodeInfo finish();
+
+	String getCodeStr();
+
+	int getLength();
+
+	StringBuilder getRawBuf();
+
+	Map<CodePosition, Object> getRawAnnotations();
+}

jadx-core/src/main/java/jadx/api/IDecompileScheduler.java

@@ -0,0 +1,7 @@
+package jadx.api;
+
+import java.util.List;
+
+public interface IDecompileScheduler {
+	List<List<JavaClass>> buildBatches(List<JavaClass> classes);
+}

jadx-core/src/main/java/jadx/api/IJadxArgs.java

@@ -1,13 +0,0 @@
-package jadx.api;
-
-public interface IJadxArgs {
-	int getThreadsCount();
-
-	boolean isCFGOutput();
-
-	boolean isRawCFGOutput();
-
-	boolean isFallbackMode();
-
-	boolean isVerbose();
-}

jadx-core/src/main/java/jadx/api/JadxArgs.java

@@ -0,0 +1,459 @@
+package jadx.api;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import jadx.api.data.ICodeData;
+import jadx.api.impl.AnnotatedCodeWriter;
+import jadx.api.impl.InMemoryCodeCache;
+
+public class JadxArgs {
+
+	public static final int DEFAULT_THREADS_COUNT = Math.max(1, Runtime.getRuntime().availableProcessors() / 2);
+
+	public static final String DEFAULT_OUT_DIR = "jadx-output";
+	public static final String DEFAULT_SRC_DIR = "sources";
+	public static final String DEFAULT_RES_DIR = "resources";
+
+	private List<File> inputFiles = new ArrayList<>(1);
+
+	private File outDir;
+	private File outDirSrc;
+	private File outDirRes;
+
+	private ICodeCache codeCache = new InMemoryCodeCache();
+	private Function<JadxArgs, ICodeWriter> codeWriterProvider = AnnotatedCodeWriter::new;
+
+	private int threadsCount = DEFAULT_THREADS_COUNT;
+
+	private boolean cfgOutput = false;
+	private boolean rawCFGOutput = false;
+
+	private boolean fallbackMode = false;
+	private boolean showInconsistentCode = false;
+
+	private boolean useImports = true;
+	private boolean debugInfo = true;
+	private boolean insertDebugLines = false;
+	private boolean extractFinally = true;
+	private boolean inlineAnonymousClasses = true;
+	private boolean inlineMethods = true;
+
+	private boolean skipResources = false;
+	private boolean skipSources = false;
+
+	/**
+	 * Predicate that allows to filter the classes to be process based on their full name
+	 */
+	private Predicate<String> classFilter = null;
+
+	private boolean deobfuscationOn = false;
+	private boolean deobfuscationForceSave = false;
+	private boolean useSourceNameAsClassAlias = false;
+	private boolean parseKotlinMetadata = false;
+	private File deobfuscationMapFile = null;
+
+	private int deobfuscationMinLength = 0;
+	private int deobfuscationMaxLength = Integer.MAX_VALUE;
+
+	private boolean escapeUnicode = false;
+	private boolean replaceConsts = true;
+	private boolean respectBytecodeAccModifiers = false;
+	private boolean exportAsGradleProject = false;
+
+	private boolean fsCaseSensitive;
+
+	public enum RenameEnum {
+		CASE, VALID, PRINTABLE
+	}
+
+	private Set<RenameEnum> renameFlags = EnumSet.allOf(RenameEnum.class);
+
+	public enum OutputFormatEnum {
+		JAVA, JSON
+	}
+
+	private OutputFormatEnum outputFormat = OutputFormatEnum.JAVA;
+
+	private ICodeData codeData;
+
+	private CommentsLevel commentsLevel = CommentsLevel.INFO;
+
+	public JadxArgs() {
+		// use default options
+	}
+
+	public void setRootDir(File rootDir) {
+		setOutDir(rootDir);
+		setOutDirSrc(new File(rootDir, DEFAULT_SRC_DIR));
+		setOutDirRes(new File(rootDir, DEFAULT_RES_DIR));
+	}
+
+	public List<File> getInputFiles() {
+		return inputFiles;
+	}
+
+	public void setInputFile(File inputFile) {
+		this.inputFiles = Collections.singletonList(inputFile);
+	}
+
+	public void setInputFiles(List<File> inputFiles) {
+		this.inputFiles = inputFiles;
+	}
+
+	public File getOutDir() {
+		return outDir;
+	}
+
+	public void setOutDir(File outDir) {
+		this.outDir = outDir;
+	}
+
+	public File getOutDirSrc() {
+		return outDirSrc;
+	}
+
+	public void setOutDirSrc(File outDirSrc) {
+		this.outDirSrc = outDirSrc;
+	}
+
+	public File getOutDirRes() {
+		return outDirRes;
+	}
+
+	public void setOutDirRes(File outDirRes) {
+		this.outDirRes = outDirRes;
+	}
+
+	public int getThreadsCount() {
+		return threadsCount;
+	}
+
+	public void setThreadsCount(int threadsCount) {
+		this.threadsCount = threadsCount;
+	}
+
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public void setCfgOutput(boolean cfgOutput) {
+		this.cfgOutput = cfgOutput;
+	}
+
+	public boolean isRawCFGOutput() {
+		return rawCFGOutput;
+	}
+
+	public void setRawCFGOutput(boolean rawCFGOutput) {
+		this.rawCFGOutput = rawCFGOutput;
+	}
+
+	public boolean isFallbackMode() {
+		return fallbackMode;
+	}
+
+	public void setFallbackMode(boolean fallbackMode) {
+		this.fallbackMode = fallbackMode;
+	}
+
+	public boolean isShowInconsistentCode() {
+		return showInconsistentCode;
+	}
+
+	public void setShowInconsistentCode(boolean showInconsistentCode) {
+		this.showInconsistentCode = showInconsistentCode;
+	}
+
+	public boolean isUseImports() {
+		return useImports;
+	}
+
+	public void setUseImports(boolean useImports) {
+		this.useImports = useImports;
+	}
+
+	public boolean isDebugInfo() {
+		return debugInfo;
+	}
+
+	public void setDebugInfo(boolean debugInfo) {
+		this.debugInfo = debugInfo;
+	}
+
+	public boolean isInsertDebugLines() {
+		return insertDebugLines;
+	}
+
+	public void setInsertDebugLines(boolean insertDebugLines) {
+		this.insertDebugLines = insertDebugLines;
+	}
+
+	public boolean isInlineAnonymousClasses() {
+		return inlineAnonymousClasses;
+	}
+
+	public void setInlineAnonymousClasses(boolean inlineAnonymousClasses) {
+		this.inlineAnonymousClasses = inlineAnonymousClasses;
+	}
+
+	public boolean isInlineMethods() {
+		return inlineMethods;
+	}
+
+	public void setInlineMethods(boolean inlineMethods) {
+		this.inlineMethods = inlineMethods;
+	}
+
+	public boolean isExtractFinally() {
+		return extractFinally;
+	}
+
+	public void setExtractFinally(boolean extractFinally) {
+		this.extractFinally = extractFinally;
+	}
+
+	public boolean isSkipResources() {
+		return skipResources;
+	}
+
+	public void setSkipResources(boolean skipResources) {
+		this.skipResources = skipResources;
+	}
+
+	public boolean isSkipSources() {
+		return skipSources;
+	}
+
+	public void setSkipSources(boolean skipSources) {
+		this.skipSources = skipSources;
+	}
+
+	public Predicate<String> getClassFilter() {
+		return classFilter;
+	}
+
+	public void setClassFilter(Predicate<String> classFilter) {
+		this.classFilter = classFilter;
+	}
+
+	public boolean isDeobfuscationOn() {
+		return deobfuscationOn;
+	}
+
+	public void setDeobfuscationOn(boolean deobfuscationOn) {
+		this.deobfuscationOn = deobfuscationOn;
+	}
+
+	public boolean isDeobfuscationForceSave() {
+		return deobfuscationForceSave;
+	}
+
+	public void setDeobfuscationForceSave(boolean deobfuscationForceSave) {
+		this.deobfuscationForceSave = deobfuscationForceSave;
+	}
+
+	public boolean isUseSourceNameAsClassAlias() {
+		return useSourceNameAsClassAlias;
+	}
+
+	public void setUseSourceNameAsClassAlias(boolean useSourceNameAsClassAlias) {
+		this.useSourceNameAsClassAlias = useSourceNameAsClassAlias;
+	}
+
+	public boolean isParseKotlinMetadata() {
+		return parseKotlinMetadata;
+	}
+
+	public void setParseKotlinMetadata(boolean parseKotlinMetadata) {
+		this.parseKotlinMetadata = parseKotlinMetadata;
+	}
+
+	public int getDeobfuscationMinLength() {
+		return deobfuscationMinLength;
+	}
+
+	public void setDeobfuscationMinLength(int deobfuscationMinLength) {
+		this.deobfuscationMinLength = deobfuscationMinLength;
+	}
+
+	public int getDeobfuscationMaxLength() {
+		return deobfuscationMaxLength;
+	}
+
+	public void setDeobfuscationMaxLength(int deobfuscationMaxLength) {
+		this.deobfuscationMaxLength = deobfuscationMaxLength;
+	}
+
+	public File getDeobfuscationMapFile() {
+		return deobfuscationMapFile;
+	}
+
+	public void setDeobfuscationMapFile(File deobfuscationMapFile) {
+		this.deobfuscationMapFile = deobfuscationMapFile;
+	}
+
+	public boolean isEscapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public void setEscapeUnicode(boolean escapeUnicode) {
+		this.escapeUnicode = escapeUnicode;
+	}
+
+	public boolean isReplaceConsts() {
+		return replaceConsts;
+	}
+
+	public void setReplaceConsts(boolean replaceConsts) {
+		this.replaceConsts = replaceConsts;
+	}
+
+	public boolean isRespectBytecodeAccModifiers() {
+		return respectBytecodeAccModifiers;
+	}
+
+	public void setRespectBytecodeAccModifiers(boolean respectBytecodeAccModifiers) {
+		this.respectBytecodeAccModifiers = respectBytecodeAccModifiers;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
+
+	public void setExportAsGradleProject(boolean exportAsGradleProject) {
+		this.exportAsGradleProject = exportAsGradleProject;
+	}
+
+	public boolean isFsCaseSensitive() {
+		return fsCaseSensitive;
+	}
+
+	public void setFsCaseSensitive(boolean fsCaseSensitive) {
+		this.fsCaseSensitive = fsCaseSensitive;
+	}
+
+	public boolean isRenameCaseSensitive() {
+		return renameFlags.contains(RenameEnum.CASE);
+	}
+
+	public void setRenameCaseSensitive(boolean renameCaseSensitive) {
+		updateRenameFlag(renameCaseSensitive, RenameEnum.CASE);
+	}
+
+	public boolean isRenameValid() {
+		return renameFlags.contains(RenameEnum.VALID);
+	}
+
+	public void setRenameValid(boolean renameValid) {
+		updateRenameFlag(renameValid, RenameEnum.VALID);
+	}
+
+	public boolean isRenamePrintable() {
+		return renameFlags.contains(RenameEnum.PRINTABLE);
+	}
+
+	public void setRenamePrintable(boolean renamePrintable) {
+		updateRenameFlag(renamePrintable, RenameEnum.PRINTABLE);
+	}
+
+	private void updateRenameFlag(boolean enabled, RenameEnum flag) {
+		if (enabled) {
+			renameFlags.add(flag);
+		} else {
+			renameFlags.remove(flag);
+		}
+	}
+
+	public void setRenameFlags(Set<RenameEnum> renameFlags) {
+		this.renameFlags = renameFlags;
+	}
+
+	public Set<RenameEnum> getRenameFlags() {
+		return renameFlags;
+	}
+
+	public OutputFormatEnum getOutputFormat() {
+		return outputFormat;
+	}
+
+	public boolean isJsonOutput() {
+		return outputFormat == OutputFormatEnum.JSON;
+	}
+
+	public void setOutputFormat(OutputFormatEnum outputFormat) {
+		this.outputFormat = outputFormat;
+	}
+
+	public ICodeCache getCodeCache() {
+		return codeCache;
+	}
+
+	public void setCodeCache(ICodeCache codeCache) {
+		this.codeCache = codeCache;
+	}
+
+	public Function<JadxArgs, ICodeWriter> getCodeWriterProvider() {
+		return codeWriterProvider;
+	}
+
+	public void setCodeWriterProvider(Function<JadxArgs, ICodeWriter> codeWriterProvider) {
+		this.codeWriterProvider = codeWriterProvider;
+	}
+
+	public ICodeData getCodeData() {
+		return codeData;
+	}
+
+	public void setCodeData(ICodeData codeData) {
+		this.codeData = codeData;
+	}
+
+	public CommentsLevel getCommentsLevel() {
+		return commentsLevel;
+	}
+
+	public void setCommentsLevel(CommentsLevel commentsLevel) {
+		this.commentsLevel = commentsLevel;
+	}
+
+	@Override
+	public String toString() {
+		return "JadxArgs{" + "inputFiles=" + inputFiles
+				+ ", outDir=" + outDir
+				+ ", outDirSrc=" + outDirSrc
+				+ ", outDirRes=" + outDirRes
+				+ ", threadsCount=" + threadsCount
+				+ ", cfgOutput=" + cfgOutput
+				+ ", rawCFGOutput=" + rawCFGOutput
+				+ ", fallbackMode=" + fallbackMode
+				+ ", showInconsistentCode=" + showInconsistentCode
+				+ ", useImports=" + useImports
+				+ ", skipResources=" + skipResources
+				+ ", skipSources=" + skipSources
+				+ ", deobfuscationOn=" + deobfuscationOn
+				+ ", deobfuscationMapFile=" + deobfuscationMapFile
+				+ ", deobfuscationForceSave=" + deobfuscationForceSave
+				+ ", useSourceNameAsClassAlias=" + useSourceNameAsClassAlias
+				+ ", parseKotlinMetadata=" + parseKotlinMetadata
+				+ ", deobfuscationMinLength=" + deobfuscationMinLength
+				+ ", deobfuscationMaxLength=" + deobfuscationMaxLength
+				+ ", escapeUnicode=" + escapeUnicode
+				+ ", replaceConsts=" + replaceConsts
+				+ ", respectBytecodeAccModifiers=" + respectBytecodeAccModifiers
+				+ ", exportAsGradleProject=" + exportAsGradleProject
+				+ ", fsCaseSensitive=" + fsCaseSensitive
+				+ ", renameFlags=" + renameFlags
+				+ ", outputFormat=" + outputFormat
+				+ ", commentsLevel=" + commentsLevel
+				+ ", codeCache=" + codeCache
+				+ ", codeWriter=" + codeWriterProvider.apply(this).getClass().getSimpleName()
+				+ '}';
+	}
+}

jadx-core/src/main/java/jadx/api/JadxArgsValidator.java

@@ -0,0 +1,98 @@
+package jadx.api;
+
+import java.io.File;
+import java.util.List;
+
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+
+public class JadxArgsValidator {
+
+	private static final Logger LOG = LoggerFactory.getLogger(JadxArgsValidator.class);
+
+	public static void validate(JadxArgs args) {
+		checkInputFiles(args);
+		validateOutDirs(args);
+
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Effective jadx args: {}", args);
+		}
+	}
+
+	private static void checkInputFiles(JadxArgs args) {
+		List<File> inputFiles = args.getInputFiles();
+		if (inputFiles.isEmpty()) {
+			throw new JadxArgsValidateException("Please specify input file");
+		}
+		for (File inputFile : inputFiles) {
+			String fileName = inputFile.getName();
+			if (fileName.startsWith("--")) {
+				throw new JadxArgsValidateException("Unknown argument: " + fileName);
+			}
+		}
+		for (File file : inputFiles) {
+			checkFile(file);
+		}
+	}
+
+	private static void validateOutDirs(JadxArgs args) {
+		File outDir = args.getOutDir();
+		File srcDir = args.getOutDirSrc();
+		File resDir = args.getOutDirRes();
+		if (outDir == null) {
+			if (srcDir != null) {
+				outDir = srcDir;
+			} else if (resDir != null) {
+				outDir = resDir;
+			} else {
+				outDir = makeDirFromInput(args);
+			}
+			args.setOutDir(outDir);
+		}
+		if (srcDir == null) {
+			args.setOutDirSrc(new File(args.getOutDir(), JadxArgs.DEFAULT_SRC_DIR));
+		}
+		if (resDir == null) {
+			args.setOutDirRes(new File(args.getOutDir(), JadxArgs.DEFAULT_RES_DIR));
+		}
+
+		checkDir(args.getOutDir(), "Output");
+		checkDir(args.getOutDirSrc(), "Source output");
+		checkDir(args.getOutDirRes(), "Resources output");
+	}
+
+	@NotNull
+	private static File makeDirFromInput(JadxArgs args) {
+		File outDir;
+		String outDirName;
+		File file = args.getInputFiles().get(0);
+		String name = file.getName();
+		int pos = name.lastIndexOf('.');
+		if (pos != -1) {
+			outDirName = name.substring(0, pos);
+		} else {
+			outDirName = name + '-' + JadxArgs.DEFAULT_OUT_DIR;
+		}
+		LOG.info("output directory: {}", outDirName);
+		outDir = new File(outDirName);
+		return outDir;
+	}
+
+	private static void checkFile(File file) {
+		if (!file.exists()) {
+			throw new JadxArgsValidateException("File not found " + file.getAbsolutePath());
+		}
+	}
+
+	private static void checkDir(File dir, String desc) {
+		if (dir != null && dir.exists() && !dir.isDirectory()) {
+			throw new JadxArgsValidateException(desc + " directory exists as file " + dir);
+		}
+	}
+
+	private JadxArgsValidator() {
+	}
+}

jadx-core/src/main/java/jadx/api/JadxDecompiler.java

@@ -0,0 +1,653 @@
+package jadx.api;
+
+import java.io.Closeable;
+import java.io.File;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.data.annotations.VarRef;
+import jadx.api.plugins.JadxPlugin;
+import jadx.api.plugins.JadxPluginManager;
+import jadx.api.plugins.input.JadxInputPlugin;
+import jadx.api.plugins.input.data.ILoadResult;
+import jadx.core.Jadx;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.attributes.nodes.LineAttrNode;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.dex.visitors.SaveCode;
+import jadx.core.export.ExportGradleProject;
+import jadx.core.utils.DecompilerScheduler;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.xmlgen.BinaryXMLParser;
+import jadx.core.xmlgen.ProtoXMLParser;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.ResourcesSaver;
+
+/**
+ * Jadx API usage example:
+ *
+ * <pre>
+ * <code>
+ *
+ * JadxArgs args = new JadxArgs();
+ * args.getInputFiles().add(new File("test.apk"));
+ * args.setOutDir(new File("jadx-test-output"));
+ * try (JadxDecompiler jadx = new JadxDecompiler(args)) {
+ *    jadx.load();
+ *    jadx.save();
+ * }
+ * </code>
+ * </pre>
+ * <p>
+ * Instead of 'save()' you can iterate over decompiled classes:
+ *
+ * <pre>
+ * <code>
+ *
+ *  for(JavaClass cls : jadx.getClasses()) {
+ *      System.out.println(cls.getCode());
+ *  }
+ * </code>
+ * </pre>
+ */
+public final class JadxDecompiler implements Closeable {
+	private static final Logger LOG = LoggerFactory.getLogger(JadxDecompiler.class);
+
+	private final JadxArgs args;
+	private final JadxPluginManager pluginManager = new JadxPluginManager();
+	private final List<ILoadResult> loadedInputs = new ArrayList<>();
+
+	private RootNode root;
+	private List<JavaClass> classes;
+	private List<ResourceFile> resources;
+
+	private BinaryXMLParser binaryXmlParser;
+	private ProtoXMLParser protoXmlParser;
+
+	private final Map<ClassNode, JavaClass> classesMap = new ConcurrentHashMap<>();
+	private final Map<MethodNode, JavaMethod> methodsMap = new ConcurrentHashMap<>();
+	private final Map<FieldNode, JavaField> fieldsMap = new ConcurrentHashMap<>();
+
+	private final IDecompileScheduler decompileScheduler = new DecompilerScheduler(this);
+
+	public JadxDecompiler() {
+		this(new JadxArgs());
+	}
+
+	public JadxDecompiler(JadxArgs args) {
+		this.args = args;
+	}
+
+	public void load() {
+		reset();
+		JadxArgsValidator.validate(args);
+		LOG.info("loading ...");
+		loadInputFiles();
+
+		root = new RootNode(args);
+		root.loadClasses(loadedInputs);
+		root.initClassPath();
+		root.loadResources(getResources());
+		root.runPreDecompileStage();
+		root.initPasses();
+	}
+
+	private void loadInputFiles() {
+		loadedInputs.clear();
+		List<Path> inputPaths = Utils.collectionMap(args.getInputFiles(), File::toPath);
+		List<Path> inputFiles = FileUtils.expandDirs(inputPaths);
+		for (JadxInputPlugin inputPlugin : pluginManager.getInputPlugins()) {
+			ILoadResult loadResult = inputPlugin.loadFiles(inputFiles);
+			if (loadResult != null && !loadResult.isEmpty()) {
+				loadedInputs.add(loadResult);
+			}
+		}
+	}
+
+	private void reset() {
+		root = null;
+		classes = null;
+		resources = null;
+		binaryXmlParser = null;
+		protoXmlParser = null;
+
+		classesMap.clear();
+		methodsMap.clear();
+		fieldsMap.clear();
+
+		closeInputs();
+	}
+
+	private void closeInputs() {
+		loadedInputs.forEach(load -> {
+			try {
+				load.close();
+			} catch (Exception e) {
+				LOG.error("Failed to close input", e);
+			}
+		});
+		loadedInputs.clear();
+	}
+
+	@Override
+	public void close() {
+		reset();
+	}
+
+	public void registerPlugin(JadxPlugin plugin) {
+		pluginManager.register(plugin);
+	}
+
+	public static String getVersion() {
+		return Jadx.getVersion();
+	}
+
+	public void save() {
+		save(!args.isSkipSources(), !args.isSkipResources());
+	}
+
+	public interface ProgressListener {
+		void progress(long done, long total);
+	}
+
+	@SuppressWarnings("BusyWait")
+	public void save(int intervalInMillis, ProgressListener listener) {
+		ThreadPoolExecutor ex = (ThreadPoolExecutor) getSaveExecutor();
+		ex.shutdown();
+		try {
+			long total = ex.getTaskCount();
+			while (ex.isTerminating()) {
+				long done = ex.getCompletedTaskCount();
+				listener.progress(done, total);
+				Thread.sleep(intervalInMillis);
+			}
+		} catch (InterruptedException e) {
+			LOG.error("Save interrupted", e);
+			Thread.currentThread().interrupt();
+		}
+	}
+
+	public void saveSources() {
+		save(true, false);
+	}
+
+	public void saveResources() {
+		save(false, true);
+	}
+
+	private void save(boolean saveSources, boolean saveResources) {
+		ExecutorService ex = getSaveExecutor(saveSources, saveResources);
+		ex.shutdown();
+		try {
+			ex.awaitTermination(1, TimeUnit.DAYS);
+		} catch (InterruptedException e) {
+			LOG.error("Save interrupted", e);
+			Thread.currentThread().interrupt();
+		}
+	}
+
+	public ExecutorService getSaveExecutor() {
+		return getSaveExecutor(!args.isSkipSources(), !args.isSkipResources());
+	}
+
+	public List<Runnable> getSaveTasks() {
+		return getSaveTasks(!args.isSkipSources(), !args.isSkipResources());
+	}
+
+	private ExecutorService getSaveExecutor(boolean saveSources, boolean saveResources) {
+		int threadsCount = args.getThreadsCount();
+		LOG.debug("processing threads count: {}", threadsCount);
+		LOG.info("processing ...");
+		ExecutorService executor = Executors.newFixedThreadPool(threadsCount);
+		List<Runnable> tasks = getSaveTasks(saveSources, saveResources);
+		tasks.forEach(executor::execute);
+		return executor;
+	}
+
+	private List<Runnable> getSaveTasks(boolean saveSources, boolean saveResources) {
+		if (root == null) {
+			throw new JadxRuntimeException("No loaded files");
+		}
+		File sourcesOutDir;
+		File resOutDir;
+		if (args.isExportAsGradleProject()) {
+			ResourceFile androidManifest = resources.stream()
+					.filter(resourceFile -> resourceFile.getType() == ResourceType.MANIFEST)
+					.findFirst()
+					.orElseThrow(IllegalStateException::new);
+
+			ResContainer strings = resources.stream()
+					.filter(resourceFile -> resourceFile.getType() == ResourceType.ARSC)
+					.findFirst()
+					.orElseThrow(IllegalStateException::new)
+					.loadContent()
+					.getSubFiles()
+					.stream()
+					.filter(resContainer -> resContainer.getFileName().contains("strings.xml"))
+					.findFirst()
+					.orElseThrow(IllegalStateException::new);
+
+			ExportGradleProject export = new ExportGradleProject(root, args.getOutDir(), androidManifest, strings);
+			export.init();
+			sourcesOutDir = export.getSrcOutDir();
+			resOutDir = export.getResOutDir();
+		} else {
+			sourcesOutDir = args.getOutDirSrc();
+			resOutDir = args.getOutDirRes();
+		}
+		List<Runnable> tasks = new ArrayList<>();
+		// save resources first because decompilation can hang or fail
+		if (saveResources) {
+			appendResourcesSaveTasks(tasks, resOutDir);
+		}
+		if (saveSources) {
+			appendSourcesSave(tasks, sourcesOutDir);
+		}
+		return tasks;
+	}
+
+	private void appendResourcesSaveTasks(List<Runnable> tasks, File outDir) {
+		Set<String> inputFileNames = args.getInputFiles().stream().map(File::getAbsolutePath).collect(Collectors.toSet());
+		for (ResourceFile resourceFile : getResources()) {
+			if (resourceFile.getType() != ResourceType.ARSC
+					&& inputFileNames.contains(resourceFile.getOriginalName())) {
+				// ignore resource made from input file
+				continue;
+			}
+			tasks.add(new ResourcesSaver(outDir, resourceFile));
+		}
+	}
+
+	private void appendSourcesSave(List<Runnable> tasks, File outDir) {
+		Predicate<String> classFilter = args.getClassFilter();
+		List<JavaClass> classes = getClasses();
+		List<JavaClass> processQueue = new ArrayList<>(classes.size());
+		for (JavaClass cls : classes) {
+			if (cls.getClassNode().contains(AFlag.DONT_GENERATE)) {
+				continue;
+			}
+			if (classFilter != null && !classFilter.test(cls.getFullName())) {
+				continue;
+			}
+			processQueue.add(cls);
+		}
+		for (List<JavaClass> decompileBatch : decompileScheduler.buildBatches(processQueue)) {
+			tasks.add(() -> {
+				for (JavaClass cls : decompileBatch) {
+					try {
+						ICodeInfo code = cls.getCodeInfo();
+						SaveCode.save(outDir, cls.getClassNode(), code);
+					} catch (Exception e) {
+						LOG.error("Error saving class: {}", cls, e);
+					}
+				}
+			});
+		}
+	}
+
+	public List<JavaClass> getClasses() {
+		if (root == null) {
+			return Collections.emptyList();
+		}
+		if (classes == null) {
+			List<ClassNode> classNodeList = root.getClasses(false);
+			List<JavaClass> clsList = new ArrayList<>(classNodeList.size());
+			classesMap.clear();
+			for (ClassNode classNode : classNodeList) {
+				if (!classNode.contains(AFlag.DONT_GENERATE)) {
+					JavaClass javaClass = new JavaClass(classNode, this);
+					clsList.add(javaClass);
+					classesMap.put(classNode, javaClass);
+				}
+			}
+			classes = Collections.unmodifiableList(clsList);
+		}
+		return classes;
+	}
+
+	public List<ResourceFile> getResources() {
+		if (resources == null) {
+			if (root == null) {
+				return Collections.emptyList();
+			}
+			resources = new ResourcesLoader(this).load();
+		}
+		return resources;
+	}
+
+	public List<JavaPackage> getPackages() {
+		List<JavaClass> classList = getClasses();
+		if (classList.isEmpty()) {
+			return Collections.emptyList();
+		}
+		Map<String, List<JavaClass>> map = new HashMap<>();
+		for (JavaClass javaClass : classList) {
+			String pkg = javaClass.getPackage();
+			List<JavaClass> clsList = map.computeIfAbsent(pkg, k -> new ArrayList<>());
+			clsList.add(javaClass);
+		}
+		List<JavaPackage> packages = new ArrayList<>(map.size());
+		for (Map.Entry<String, List<JavaClass>> entry : map.entrySet()) {
+			packages.add(new JavaPackage(entry.getKey(), entry.getValue()));
+		}
+		Collections.sort(packages);
+		for (JavaPackage pkg : packages) {
+			pkg.getClasses().sort(Comparator.comparing(JavaClass::getName, String.CASE_INSENSITIVE_ORDER));
+		}
+		return Collections.unmodifiableList(packages);
+	}
+
+	public int getErrorsCount() {
+		if (root == null) {
+			return 0;
+		}
+		return root.getErrorsCounter().getErrorCount();
+	}
+
+	public int getWarnsCount() {
+		if (root == null) {
+			return 0;
+		}
+		return root.getErrorsCounter().getWarnsCount();
+	}
+
+	public void printErrorsReport() {
+		if (root == null) {
+			return;
+		}
+		root.getClsp().printMissingClasses();
+		root.getErrorsCounter().printReport();
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	public RootNode getRoot() {
+		return root;
+	}
+
+	synchronized BinaryXMLParser getBinaryXmlParser() {
+		if (binaryXmlParser == null) {
+			binaryXmlParser = new BinaryXMLParser(root);
+		}
+		return binaryXmlParser;
+	}
+
+	synchronized ProtoXMLParser getProtoXmlParser() {
+		if (protoXmlParser == null) {
+			protoXmlParser = new ProtoXMLParser(root);
+		}
+		return protoXmlParser;
+	}
+
+	private void loadJavaClass(JavaClass javaClass) {
+		javaClass.getMethods().forEach(mth -> methodsMap.put(mth.getMethodNode(), mth));
+		javaClass.getFields().forEach(fld -> fieldsMap.put(fld.getFieldNode(), fld));
+
+		for (JavaClass innerCls : javaClass.getInnerClasses()) {
+			classesMap.put(innerCls.getClassNode(), innerCls);
+			loadJavaClass(innerCls);
+		}
+	}
+
+	/**
+	 * Get JavaClass by ClassNode without loading and decompilation
+	 */
+	JavaClass convertClassNode(ClassNode cls) {
+		return classesMap.compute(cls, (node, prevJavaCls) -> {
+			if (prevJavaCls != null && prevJavaCls.getClassNode() == cls) {
+				// keep previous variable
+				return prevJavaCls;
+			}
+			if (cls.isInner()) {
+				return new JavaClass(cls, convertClassNode(cls.getParentClass()));
+			}
+			return new JavaClass(cls, this);
+		});
+	}
+
+	@Nullable("For not generated classes")
+	@ApiStatus.Internal
+	public JavaClass getJavaClassByNode(ClassNode cls) {
+		JavaClass javaClass = classesMap.get(cls);
+		if (javaClass != null && javaClass.getClassNode() == cls) {
+			return javaClass;
+		}
+		// load parent class if inner
+		ClassNode parentClass = cls.getTopParentClass();
+		if (parentClass.contains(AFlag.DONT_GENERATE)) {
+			return null;
+		}
+		if (parentClass != cls) {
+			JavaClass parentJavaClass = classesMap.get(parentClass);
+			if (parentJavaClass == null) {
+				getClasses();
+				parentJavaClass = classesMap.get(parentClass);
+			}
+			loadJavaClass(parentJavaClass);
+			javaClass = classesMap.get(cls);
+			if (javaClass != null) {
+				return javaClass;
+			}
+		}
+		// class or parent classes can be excluded from generation
+		if (cls.hasNotGeneratedParent()) {
+			return null;
+		}
+		throw new JadxRuntimeException("JavaClass not found by ClassNode: " + cls);
+	}
+
+	@Nullable
+	private JavaMethod getJavaMethodByNode(MethodNode mth) {
+		JavaMethod javaMethod = methodsMap.get(mth);
+		if (javaMethod != null && javaMethod.getMethodNode() == mth) {
+			return javaMethod;
+		}
+		if (mth.contains(AFlag.DONT_GENERATE)) {
+			return null;
+		}
+		// parent class not loaded yet
+		JavaClass javaClass = getJavaClassByNode(mth.getParentClass().getTopParentClass());
+		if (javaClass == null) {
+			return null;
+		}
+		loadJavaClass(javaClass);
+		javaMethod = methodsMap.get(mth);
+		if (javaMethod != null) {
+			return javaMethod;
+		}
+		if (mth.getParentClass().hasNotGeneratedParent()) {
+			return null;
+		}
+		throw new JadxRuntimeException("JavaMethod not found by MethodNode: " + mth);
+	}
+
+	@Nullable
+	private JavaField getJavaFieldByNode(FieldNode fld) {
+		JavaField javaField = fieldsMap.get(fld);
+		if (javaField != null && javaField.getFieldNode() == fld) {
+			return javaField;
+		}
+		// parent class not loaded yet
+		JavaClass javaClass = getJavaClassByNode(fld.getParentClass().getTopParentClass());
+		if (javaClass == null) {
+			return null;
+		}
+		loadJavaClass(javaClass);
+		javaField = fieldsMap.get(fld);
+		if (javaField != null) {
+			return javaField;
+		}
+		if (fld.getParentClass().hasNotGeneratedParent()) {
+			return null;
+		}
+		throw new JadxRuntimeException("JavaField not found by FieldNode: " + fld);
+	}
+
+	@Nullable
+	public JavaClass searchJavaClassByOrigFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.map(this::getJavaClassByNode)
+				.orElse(null);
+	}
+
+	@Nullable
+	public ClassNode searchClassNodeByOrigFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.orElse(null);
+	}
+
+	// returns parent if class contains DONT_GENERATE flag.
+	@Nullable
+	public JavaClass searchJavaClassOrItsParentByOrigFullName(String fullName) {
+		ClassNode node = getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.orElse(null);
+		if (node != null) {
+			if (node.contains(AFlag.DONT_GENERATE)) {
+				return getJavaClassByNode(node.getTopParentClass());
+			} else {
+				return getJavaClassByNode(node);
+			}
+		}
+		return null;
+	}
+
+	@Nullable
+	public JavaClass searchJavaClassByAliasFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getAliasFullName().equals(fullName))
+				.findFirst()
+				.map(this::getJavaClassByNode)
+				.orElse(null);
+	}
+
+	@Nullable
+	JavaNode convertNode(Object obj) {
+		if (obj instanceof VarRef) {
+			VarRef varRef = (VarRef) obj;
+			MethodNode mthNode = varRef.getMth();
+			JavaMethod mth = getJavaMethodByNode(mthNode);
+			if (mth == null) {
+				return null;
+			}
+			return new JavaVariable(mth, varRef);
+		}
+		if (!(obj instanceof LineAttrNode)) {
+			return null;
+		}
+		LineAttrNode node = (LineAttrNode) obj;
+		if (node.contains(AFlag.DONT_GENERATE)) {
+			return null;
+		}
+		if (obj instanceof ClassNode) {
+			return convertClassNode((ClassNode) obj);
+		}
+		if (obj instanceof MethodNode) {
+			return getJavaMethodByNode(((MethodNode) obj));
+		}
+		if (obj instanceof FieldNode) {
+			return getJavaFieldByNode((FieldNode) obj);
+		}
+		throw new JadxRuntimeException("Unexpected node type: " + obj);
+	}
+
+	// TODO: make interface for all nodes in code annotations and add common method instead this
+	Object getInternalNode(JavaNode javaNode) {
+		if (javaNode instanceof JavaClass) {
+			return ((JavaClass) javaNode).getClassNode();
+		}
+		if (javaNode instanceof JavaMethod) {
+			return ((JavaMethod) javaNode).getMethodNode();
+		}
+		if (javaNode instanceof JavaField) {
+			return ((JavaField) javaNode).getFieldNode();
+		}
+		if (javaNode instanceof JavaVariable) {
+			return ((JavaVariable) javaNode).getVarRef();
+		}
+		throw new JadxRuntimeException("Unexpected node type: " + javaNode);
+	}
+
+	List<JavaNode> convertNodes(Collection<?> nodesList) {
+		return nodesList.stream()
+				.map(this::convertNode)
+				.filter(Objects::nonNull)
+				.collect(Collectors.toList());
+	}
+
+	@Nullable
+	public JavaNode getJavaNodeAtPosition(ICodeInfo codeInfo, int line, int offset) {
+		Map<CodePosition, Object> map = codeInfo.getAnnotations();
+		if (map.isEmpty()) {
+			return null;
+		}
+		Object obj = map.get(new CodePosition(line, offset));
+		if (obj == null) {
+			return null;
+		}
+		return convertNode(obj);
+	}
+
+	@Nullable
+	public CodePosition getDefinitionPosition(JavaNode javaNode) {
+		JavaClass jCls = javaNode.getTopParentClass();
+		jCls.decompile();
+		int defLine = javaNode.getDecompiledLine();
+		if (defLine == 0) {
+			return null;
+		}
+		return new CodePosition(defLine, 0, javaNode.getDefPos());
+	}
+
+	public void reloadCodeData() {
+		root.notifyCodeDataListeners();
+	}
+
+	public JadxArgs getArgs() {
+		return args;
+	}
+
+	public JadxPluginManager getPluginManager() {
+		return pluginManager;
+	}
+
+	public IDecompileScheduler getDecompileScheduler() {
+		return decompileScheduler;
+	}
+
+	@Override
+	public String toString() {
+		return "jadx decompiler " + getVersion();
+	}
+}

jadx-core/src/main/java/jadx/api/JavaClass.java

@@ -1,113 +1,305 @@
 package jadx.api;
 
-import jadx.core.codegen.CodeWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.MethodNode;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
+public final class JavaClass implements JavaNode {
 
-public final class JavaClass {
-
-	private final Decompiler decompiler;
+	private final JadxDecompiler decompiler;
 	private final ClassNode cls;
-	private final List<JavaClass> innerClasses;
-	private final List<JavaField> fields;
-	private final List<JavaMethod> methods;
+	private final JavaClass parent;
 
-	JavaClass(Decompiler decompiler, ClassNode classNode) {
+	private List<JavaClass> innerClasses = Collections.emptyList();
+	private List<JavaField> fields = Collections.emptyList();
+	private List<JavaMethod> methods = Collections.emptyList();
+	private boolean listsLoaded;
+
+	JavaClass(ClassNode classNode, JadxDecompiler decompiler) {
 		this.decompiler = decompiler;
 		this.cls = classNode;
+		this.parent = null;
+	}
+
+	/**
+	 * Inner classes constructor
+	 */
+	JavaClass(ClassNode classNode, JavaClass parent) {
+		this.decompiler = null;
+		this.cls = classNode;
+		this.parent = parent;
+	}
+
+	public String getCode() {
+		ICodeInfo code = getCodeInfo();
+		if (code == null) {
+			return "";
+		}
+		return code.getCodeStr();
+	}
+
+	public ICodeInfo getCodeInfo() {
+		return cls.decompile();
+	}
+
+	public void decompile() {
+		cls.decompile();
+	}
+
+	public synchronized void reload() {
+		listsLoaded = false;
+		cls.reloadCode();
+	}
+
+	public void unload() {
+		listsLoaded = false;
+		cls.unloadCode();
+	}
+
+	public synchronized String getSmali() {
+		return cls.getDisassembledCode();
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public ClassNode getClassNode() {
+		return cls;
+	}
+
+	private synchronized void loadLists() {
+		if (listsLoaded) {
+			return;
+		}
+		listsLoaded = true;
+		decompile();
+		JadxDecompiler rootDecompiler = getRootDecompiler();
 
 		int inClsCount = cls.getInnerClasses().size();
-		if (inClsCount == 0) {
-			this.innerClasses = Collections.emptyList();
-		} else {
-			List<JavaClass> list = new ArrayList<JavaClass>(inClsCount);
+		if (inClsCount != 0) {
+			List<JavaClass> list = new ArrayList<>(inClsCount);
 			for (ClassNode inner : cls.getInnerClasses()) {
-				list.add(new JavaClass(decompiler, inner));
+				if (!inner.contains(AFlag.DONT_GENERATE)) {
+					JavaClass javaClass = rootDecompiler.convertClassNode(inner);
+					javaClass.loadLists();
+					list.add(javaClass);
+				}
 			}
 			this.innerClasses = Collections.unmodifiableList(list);
 		}
 
 		int fieldsCount = cls.getFields().size();
-		if (fieldsCount == 0) {
-			this.fields = Collections.emptyList();
-		} else {
-			List<JavaField> flds = new ArrayList<JavaField>(fieldsCount);
+		if (fieldsCount != 0) {
+			List<JavaField> flds = new ArrayList<>(fieldsCount);
 			for (FieldNode f : cls.getFields()) {
-				flds.add(new JavaField(f));
+				if (!f.contains(AFlag.DONT_GENERATE)) {
+					JavaField javaField = new JavaField(f, this);
+					flds.add(javaField);
+				}
 			}
 			this.fields = Collections.unmodifiableList(flds);
 		}
 
 		int methodsCount = cls.getMethods().size();
-		if (methodsCount == 0) {
-			this.methods = Collections.emptyList();
-		} else {
-			List<JavaMethod> mths = new ArrayList<JavaMethod>(methodsCount);
+		if (methodsCount != 0) {
+			List<JavaMethod> mths = new ArrayList<>(methodsCount);
 			for (MethodNode m : cls.getMethods()) {
-				if (!m.getAccessFlags().isSynthetic()) {
-					mths.add(new JavaMethod(m));
+				if (!m.contains(AFlag.DONT_GENERATE)) {
+					JavaMethod javaMethod = new JavaMethod(this, m);
+					mths.add(javaMethod);
 				}
 			}
-			Collections.sort(mths, new Comparator<JavaMethod>() {
-				@Override
-				public int compare(JavaMethod o1, JavaMethod o2) {
-					return o1.getName().compareTo(o2.getName());
-				}
-			});
+			mths.sort(Comparator.comparing(JavaMethod::getName));
 			this.methods = Collections.unmodifiableList(mths);
 		}
 	}
 
-	public String getCode() {
-		CodeWriter code = cls.getCode();
-		if (code == null) {
-			decompiler.processClass(cls);
-			code = cls.getCode();
+	protected JadxDecompiler getRootDecompiler() {
+		if (parent != null) {
+			return parent.getRootDecompiler();
 		}
-		return code != null ? code.toString() : "error processing class";
+		return decompiler;
 	}
 
+	public Map<CodePosition, Object> getCodeAnnotations() {
+		ICodeInfo code = getCodeInfo();
+		if (code == null) {
+			return Collections.emptyMap();
+		}
+		return code.getAnnotations();
+	}
+
+	public Object getAnnotationAt(CodePosition pos) {
+		return getCodeAnnotations().get(pos);
+	}
+
+	public Map<CodePosition, JavaNode> getUsageMap() {
+		Map<CodePosition, Object> map = getCodeAnnotations();
+		if (map.isEmpty() || decompiler == null) {
+			return Collections.emptyMap();
+		}
+		Map<CodePosition, JavaNode> resultMap = new HashMap<>(map.size());
+		for (Map.Entry<CodePosition, Object> entry : map.entrySet()) {
+			CodePosition codePosition = entry.getKey();
+			Object obj = entry.getValue();
+			JavaNode node = getRootDecompiler().convertNode(obj);
+			if (node != null) {
+				resultMap.put(codePosition, node);
+			}
+		}
+		return resultMap;
+	}
+
+	public List<CodePosition> getUsageFor(JavaNode javaNode) {
+		Map<CodePosition, Object> map = getCodeAnnotations();
+		if (map.isEmpty() || decompiler == null) {
+			return Collections.emptyList();
+		}
+		Object internalNode = getRootDecompiler().getInternalNode(javaNode);
+		List<CodePosition> result = new ArrayList<>();
+		for (Map.Entry<CodePosition, Object> entry : map.entrySet()) {
+			CodePosition codePosition = entry.getKey();
+			Object obj = entry.getValue();
+			if (internalNode.equals(obj)) {
+				result.add(codePosition);
+			}
+		}
+		return result;
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getRootDecompiler().convertNodes(cls.getUseIn());
+	}
+
+	@Nullable
+	@Deprecated
+	public JavaNode getJavaNodeAtPosition(int line, int offset) {
+		return getRootDecompiler().getJavaNodeAtPosition(getCodeInfo(), line, offset);
+	}
+
+	@Nullable
+	@Deprecated
+	public CodePosition getDefinitionPosition() {
+		return getRootDecompiler().getDefinitionPosition(this);
+	}
+
+	public Integer getSourceLine(int decompiledLine) {
+		return getCodeInfo().getLineMapping().get(decompiledLine);
+	}
+
+	@Override
+	public String getName() {
+		return cls.getShortName();
+	}
+
+	@Override
 	public String getFullName() {
 		return cls.getFullName();
 	}
 
-	public String getShortName() {
-		return cls.getShortName();
+	public String getRawName() {
+		return cls.getRawName();
 	}
 
 	public String getPackage() {
 		return cls.getPackage();
 	}
 
+	@Override
+	public JavaClass getDeclaringClass() {
+		return parent;
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		if (cls.contains(AFlag.ANONYMOUS_CLASS)) {
+			// moved to usage class
+			return getParentForAnonymousClass();
+		}
+		return parent == null ? this : parent.getTopParentClass();
+	}
+
+	private JavaClass getParentForAnonymousClass() {
+		List<JavaNode> useIn = getUseIn();
+		if (useIn.isEmpty()) {
+			return this;
+		}
+		JavaNode useNode = useIn.get(0);
+		if (useNode.equals(this)) {
+			return this;
+		}
+		return useNode.getTopParentClass();
+	}
+
 	public AccessInfo getAccessInfo() {
 		return cls.getAccessFlags();
 	}
 
 	public List<JavaClass> getInnerClasses() {
+		loadLists();
 		return innerClasses;
 	}
 
 	public List<JavaField> getFields() {
+		loadLists();
 		return fields;
 	}
 
 	public List<JavaMethod> getMethods() {
+		loadLists();
 		return methods;
 	}
 
+	@Nullable
+	public JavaMethod searchMethodByShortId(String shortId) {
+		MethodNode methodNode = cls.searchMethodByShortId(shortId);
+		if (methodNode == null) {
+			return null;
+		}
+		return new JavaMethod(this, methodNode);
+	}
+
+	@Override
+	public void removeAlias() {
+		this.cls.getClassInfo().removeAlias();
+	}
+
+	@Override
+	public int getDecompiledLine() {
+		return cls.getDecompiledLine();
+	}
+
+	@Override
+	public int getDefPos() {
+		return cls.getDefPosition();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return this == o || o instanceof JavaClass && cls.equals(((JavaClass) o).cls);
+	}
+
+	@Override
+	public int hashCode() {
+		return cls.hashCode();
+	}
+
 	@Override
 	public String toString() {
 		return getFullName();
 	}
-
-	public int getDecompiledLine() {
-		return cls.getDecompiledLine();
-	}
 }

jadx-core/src/main/java/jadx/api/JavaField.java

@@ -1,19 +1,41 @@
 package jadx.api;
 
+import java.util.List;
+
+import org.jetbrains.annotations.ApiStatus;
+
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.FieldNode;
 
-public final class JavaField {
+public final class JavaField implements JavaNode {
 
 	private final FieldNode field;
+	private final JavaClass parent;
 
-	public JavaField(FieldNode f) {
+	JavaField(FieldNode f, JavaClass cls) {
 		this.field = f;
+		this.parent = cls;
 	}
 
+	@Override
 	public String getName() {
-		return field.getName();
+		return field.getAlias();
+	}
+
+	@Override
+	public String getFullName() {
+		return parent.getFullName() + '.' + getName();
+	}
+
+	@Override
+	public JavaClass getDeclaringClass() {
+		return parent;
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
 	}
 
 	public AccessInfo getAccessFlags() {
@@ -21,10 +43,49 @@ public final class JavaField {
 	}
 
 	public ArgType getType() {
-		return field.getType();
+		return ArgType.tryToResolveClassAlias(field.root(), field.getType());
 	}
 
+	@Override
 	public int getDecompiledLine() {
 		return field.getDecompiledLine();
 	}
+
+	@Override
+	public int getDefPos() {
+		return field.getDefPosition();
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getDeclaringClass().getRootDecompiler().convertNodes(field.getUseIn());
+	}
+
+	@Override
+	public void removeAlias() {
+		this.field.getFieldInfo().removeAlias();
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public FieldNode getFieldNode() {
+		return field;
+	}
+
+	@Override
+	public int hashCode() {
+		return field.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return this == o || o instanceof JavaField && field.equals(((JavaField) o).field);
+	}
+
+	@Override
+	public String toString() {
+		return field.toString();
+	}
 }

jadx-core/src/main/java/jadx/api/JavaMethod.java

@@ -1,27 +1,45 @@
 package jadx.api;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.nodes.MethodOverrideAttr;
 import jadx.core.dex.info.AccessInfo;
-import jadx.core.dex.info.MethodInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.MethodNode;
+import jadx.core.utils.Utils;
 
-import java.util.List;
-
-public final class JavaMethod {
+public final class JavaMethod implements JavaNode {
 	private final MethodNode mth;
+	private final JavaClass parent;
 
-	public JavaMethod(MethodNode m) {
+	JavaMethod(JavaClass cls, MethodNode m) {
+		this.parent = cls;
 		this.mth = m;
 	}
 
+	@Override
 	public String getName() {
-		MethodInfo mi = mth.getMethodInfo();
-		if (mi.isConstructor()) {
-			return mth.getParentClass().getShortName();
-		} else if (mi.isClassInit()) {
-			return "static";
-		}
-		return mi.getName();
+		return mth.getAlias();
+	}
+
+	@Override
+	public String getFullName() {
+		return mth.getMethodInfo().getFullName();
+	}
+
+	@Override
+	public JavaClass getDeclaringClass() {
+		return parent;
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
 	}
 
 	public AccessInfo getAccessFlags() {
@@ -29,11 +47,34 @@ public final class JavaMethod {
 	}
 
 	public List<ArgType> getArguments() {
-		return mth.getMethodInfo().getArgumentsTypes();
+		List<ArgType> infoArgTypes = mth.getMethodInfo().getArgumentsTypes();
+		if (infoArgTypes.isEmpty()) {
+			return Collections.emptyList();
+		}
+		List<ArgType> arguments = mth.getArgTypes();
+		return Utils.collectionMap(arguments,
+				type -> ArgType.tryToResolveClassAlias(mth.root(), type));
 	}
 
 	public ArgType getReturnType() {
-		return mth.getReturnType();
+		ArgType retType = mth.getReturnType();
+		return ArgType.tryToResolveClassAlias(mth.root(), retType);
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getDeclaringClass().getRootDecompiler().convertNodes(mth.getUseIn());
+	}
+
+	public List<JavaMethod> getOverrideRelatedMethods() {
+		MethodOverrideAttr ovrdAttr = mth.get(AType.METHOD_OVERRIDE);
+		if (ovrdAttr == null) {
+			return Collections.emptyList();
+		}
+		JadxDecompiler decompiler = getDeclaringClass().getRootDecompiler();
+		return ovrdAttr.getRelatedMthNodes().stream()
+				.map(m -> ((JavaMethod) decompiler.convertNode(m)))
+				.collect(Collectors.toList());
 	}
 
 	public boolean isConstructor() {
@@ -44,7 +85,41 @@ public final class JavaMethod {
 		return mth.getMethodInfo().isClassInit();
 	}
 
+	@Override
 	public int getDecompiledLine() {
 		return mth.getDecompiledLine();
 	}
+
+	@Override
+	public int getDefPos() {
+		return mth.getDefPosition();
+	}
+
+	@Override
+	public void removeAlias() {
+		this.mth.getMethodInfo().removeAlias();
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public MethodNode getMethodNode() {
+		return mth;
+	}
+
+	@Override
+	public int hashCode() {
+		return mth.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return this == o || o instanceof JavaMethod && mth.equals(((JavaMethod) o).mth);
+	}
+
+	@Override
+	public String toString() {
+		return mth.toString();
+	}
 }

jadx-core/src/main/java/jadx/api/JavaNode.java

@@ -0,0 +1,23 @@
+package jadx.api;
+
+import java.util.List;
+
+public interface JavaNode {
+
+	String getName();
+
+	String getFullName();
+
+	JavaClass getDeclaringClass();
+
+	JavaClass getTopParentClass();
+
+	int getDecompiledLine();
+
+	int getDefPos();
+
+	List<JavaNode> getUseIn();
+
+	default void removeAlias() {
+	}
+}

jadx-core/src/main/java/jadx/api/JavaPackage.java

@@ -1,8 +1,11 @@
 package jadx.api;
 
+import java.util.Collections;
 import java.util.List;
 
-public final class JavaPackage implements Comparable<JavaPackage> {
+import org.jetbrains.annotations.NotNull;
+
+public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 	private final String name;
 	private final List<JavaClass> classes;
 
@@ -11,26 +14,61 @@ public final class JavaPackage implements Comparable<JavaPackage> {
 		this.classes = classes;
 	}
 
+	@Override
 	public String getName() {
 		return name;
 	}
 
+	@Override
+	public String getFullName() {
+		// TODO: store full package name
+		return name;
+	}
+
 	public List<JavaClass> getClasses() {
 		return classes;
 	}
 
 	@Override
-	public int compareTo(JavaPackage o) {
+	public JavaClass getDeclaringClass() {
+		return null;
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return null;
+	}
+
+	@Override
+	public int getDecompiledLine() {
+		return 0;
+	}
+
+	@Override
+	public int getDefPos() {
+		return 0;
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return Collections.emptyList();
+	}
+
+	@Override
+	public int compareTo(@NotNull JavaPackage o) {
 		return name.compareTo(o.name);
 	}
 
 	@Override
 	public boolean equals(Object o) {
-		if (this == o) return true;
-		if (o == null || getClass() != o.getClass()) return false;
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
 		JavaPackage that = (JavaPackage) o;
-		if (!name.equals(that.name)) return false;
-		return true;
+		return name.equals(that.name);
 	}
 
 	@Override

jadx-core/src/main/java/jadx/api/JavaVariable.java

@@ -0,0 +1,93 @@
+package jadx.api;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import jadx.api.data.annotations.VarDeclareRef;
+import jadx.api.data.annotations.VarRef;
+
+public class JavaVariable implements JavaNode {
+	private final JavaMethod mth;
+	private final VarRef varRef;
+
+	public JavaVariable(JavaMethod mth, VarRef varRef) {
+		this.mth = mth;
+		this.varRef = varRef;
+	}
+
+	public JavaMethod getMth() {
+		return mth;
+	}
+
+	public int getReg() {
+		return varRef.getReg();
+	}
+
+	public int getSsa() {
+		return varRef.getSsa();
+	}
+
+	@Override
+	public String getName() {
+		return varRef.getName();
+	}
+
+	@ApiStatus.Internal
+	public VarRef getVarRef() {
+		return varRef;
+	}
+
+	@Override
+	public String getFullName() {
+		return varRef.getType() + " " + varRef.getName() + " (r" + varRef.getReg() + "v" + varRef.getSsa() + ")";
+	}
+
+	@Override
+	public JavaClass getDeclaringClass() {
+		return mth.getDeclaringClass();
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return mth.getTopParentClass();
+	}
+
+	@Override
+	public int getDecompiledLine() {
+		if (varRef instanceof VarDeclareRef) {
+			return ((VarDeclareRef) varRef).getDecompiledLine();
+		}
+		return 0;
+	}
+
+	@Override
+	public int getDefPos() {
+		if (varRef instanceof VarDeclareRef) {
+			return ((VarDeclareRef) varRef).getDefPosition();
+		}
+		return 0;
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return Collections.singletonList(mth);
+	}
+
+	@Override
+	public int hashCode() {
+		return varRef.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof JavaVariable)) {
+			return false;
+		}
+		return varRef.equals(((JavaVariable) o).varRef);
+	}
+}

jadx-core/src/main/java/jadx/api/ResourceFile.java

@@ -0,0 +1,90 @@
+package jadx.api;
+
+import java.io.File;
+
+import jadx.api.plugins.utils.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.entry.ResourceEntry;
+
+public class ResourceFile {
+
+	public static final class ZipRef {
+		private final File zipFile;
+		private final String entryName;
+
+		public ZipRef(File zipFile, String entryName) {
+			this.zipFile = zipFile;
+			this.entryName = entryName;
+		}
+
+		public File getZipFile() {
+			return zipFile;
+		}
+
+		public String getEntryName() {
+			return entryName;
+		}
+
+		@Override
+		public String toString() {
+			return "ZipRef{" + zipFile + ", '" + entryName + "'}";
+		}
+	}
+
+	private final JadxDecompiler decompiler;
+	private final String name;
+	private final ResourceType type;
+	private ZipRef zipRef;
+	private String deobfName;
+
+	public static ResourceFile createResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+		if (!ZipSecurity.isValidZipEntryName(name)) {
+			return null;
+		}
+		return new ResourceFile(decompiler, name, type);
+	}
+
+	protected ResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+		this.decompiler = decompiler;
+		this.name = name;
+		this.type = type;
+	}
+
+	public String getOriginalName() {
+		return name;
+	}
+
+	public String getDeobfName() {
+		return deobfName != null ? deobfName : name;
+	}
+
+	public ResourceType getType() {
+		return type;
+	}
+
+	public ResContainer loadContent() {
+		return ResourcesLoader.loadContent(decompiler, this);
+	}
+
+	void setZipRef(ZipRef zipRef) {
+		this.zipRef = zipRef;
+	}
+
+	public void setAlias(ResourceEntry ri) {
+		int index = name.lastIndexOf('.');
+		deobfName = String.format("res/%s%s/%s%s",
+				ri.getTypeName(),
+				ri.getConfig(),
+				ri.getKeyName(),
+				index == -1 ? "" : name.substring(index));
+	}
+
+	public ZipRef getZipRef() {
+		return zipRef;
+	}
+
+	@Override
+	public String toString() {
+		return "ResourceFile{name='" + name + '\'' + ", type=" + type + '}';
+	}
+}

jadx-core/src/main/java/jadx/api/ResourceFileContent.java

@@ -0,0 +1,17 @@
+package jadx.api;
+
+import jadx.core.xmlgen.ResContainer;
+
+public class ResourceFileContent extends ResourceFile {
+	private final ICodeInfo content;
+
+	public ResourceFileContent(String name, ResourceType type, ICodeInfo content) {
+		super(null, name, type);
+		this.content = content;
+	}
+
+	@Override
+	public ResContainer loadContent() {
+		return ResContainer.textResource(getDeobfName(), content);
+	}
+}

jadx-core/src/main/java/jadx/api/ResourceType.java

@@ -0,0 +1,60 @@
+package jadx.api;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
+public enum ResourceType {
+	CODE(".dex", ".jar", ".class"),
+	XML(".xml"),
+	ARSC(".arsc"),
+	FONT(".ttf", ".otf"),
+	IMG(".png", ".gif", ".jpg"),
+	MEDIA(".mp3", ".wav"),
+	LIB(".so"),
+	MANIFEST,
+	UNKNOWN;
+
+	private final String[] exts;
+
+	ResourceType(String... exts) {
+		this.exts = exts;
+	}
+
+	public String[] getExts() {
+		return exts;
+	}
+
+	private static final Map<String, ResourceType> EXT_MAP = new HashMap<>();
+
+	static {
+		for (ResourceType type : ResourceType.values()) {
+			for (String ext : type.getExts()) {
+				ResourceType prev = EXT_MAP.put(ext, type);
+				if (prev != null) {
+					throw new JadxRuntimeException("Duplicate extension in ResourceType: " + ext);
+				}
+			}
+		}
+	}
+
+	public static ResourceType getFileType(String fileName) {
+		if (fileName.matches("[^/]+/resources.pb")) {
+			return ARSC;
+		}
+		int dot = fileName.lastIndexOf('.');
+		if (dot != -1) {
+			String ext = fileName.substring(dot).toLowerCase(Locale.ROOT);
+			ResourceType resType = EXT_MAP.get(ext);
+			if (resType != null) {
+				if (resType == XML && fileName.equals("AndroidManifest.xml")) {
+					return MANIFEST;
+				}
+				return resType;
+			}
+		}
+		return UNKNOWN;
+	}
+}

jadx-core/src/main/java/jadx/api/ResourcesLoader.java

@@ -0,0 +1,179 @@
+package jadx.api;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.ResourceFile.ZipRef;
+import jadx.api.impl.SimpleCodeInfo;
+import jadx.api.plugins.utils.ZipSecurity;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.Utils;
+import jadx.core.utils.android.Res9patchStreamDecoder;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.ResProtoParser;
+import jadx.core.xmlgen.ResTableParser;
+
+import static jadx.core.utils.files.FileUtils.READ_BUFFER_SIZE;
+import static jadx.core.utils.files.FileUtils.copyStream;
+
+// TODO: move to core package
+public final class ResourcesLoader {
+	private static final Logger LOG = LoggerFactory.getLogger(ResourcesLoader.class);
+
+	private final JadxDecompiler jadxRef;
+
+	ResourcesLoader(JadxDecompiler jadxRef) {
+		this.jadxRef = jadxRef;
+	}
+
+	List<ResourceFile> load() {
+		List<File> inputFiles = jadxRef.getArgs().getInputFiles();
+		List<ResourceFile> list = new ArrayList<>(inputFiles.size());
+		for (File file : inputFiles) {
+			loadFile(list, file);
+		}
+		return list;
+	}
+
+	public interface ResourceDecoder<T> {
+		T decode(long size, InputStream is) throws IOException;
+	}
+
+	public static <T> T decodeStream(ResourceFile rf, ResourceDecoder<T> decoder) throws JadxException {
+		try {
+			ZipRef zipRef = rf.getZipRef();
+			if (zipRef == null) {
+				File file = new File(rf.getOriginalName());
+				try (InputStream inputStream = new BufferedInputStream(new FileInputStream(file))) {
+					return decoder.decode(file.length(), inputStream);
+				}
+			} else {
+				try (ZipFile zipFile = new ZipFile(zipRef.getZipFile())) {
+					ZipEntry entry = zipFile.getEntry(zipRef.getEntryName());
+					if (entry == null) {
+						throw new IOException("Zip entry not found: " + zipRef);
+					}
+					if (!ZipSecurity.isValidZipEntry(entry)) {
+						return null;
+					}
+					try (InputStream inputStream = ZipSecurity.getInputStreamForEntry(zipFile, entry)) {
+						return decoder.decode(entry.getSize(), inputStream);
+					}
+				}
+			}
+		} catch (Exception e) {
+			throw new JadxException("Error decode: " + rf.getDeobfName(), e);
+		}
+	}
+
+	static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf) {
+		try {
+			return decodeStream(rf, (size, is) -> loadContent(jadxRef, rf, is));
+		} catch (JadxException e) {
+			LOG.error("Decode error", e);
+			ICodeWriter cw = jadxRef.getRoot().makeCodeWriter();
+			cw.add("Error decode ").add(rf.getType().toString().toLowerCase());
+			Utils.appendStackTrace(cw, e.getCause());
+			return ResContainer.textResource(rf.getDeobfName(), cw.finish());
+		}
+	}
+
+	private static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf,
+			InputStream inputStream) throws IOException {
+		RootNode root = jadxRef.getRoot();
+		switch (rf.getType()) {
+			case MANIFEST:
+			case XML: {
+				ICodeInfo content;
+				if (root.isProto()) {
+					content = jadxRef.getProtoXmlParser().parse(inputStream);
+				} else {
+					content = jadxRef.getBinaryXmlParser().parse(inputStream);
+				}
+				return ResContainer.textResource(rf.getDeobfName(), content);
+			}
+
+			case ARSC:
+				if (root.isProto()) {
+					return new ResProtoParser(root).decodeFiles(inputStream);
+				} else {
+					return new ResTableParser(root).decodeFiles(inputStream);
+				}
+
+			case IMG:
+				return decodeImage(rf, inputStream);
+
+			default:
+				return ResContainer.resourceFileLink(rf);
+		}
+	}
+
+	private static ResContainer decodeImage(ResourceFile rf, InputStream inputStream) {
+		String name = rf.getOriginalName();
+		if (name.endsWith(".9.png")) {
+			try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
+				Res9patchStreamDecoder decoder = new Res9patchStreamDecoder();
+				decoder.decode(inputStream, os);
+				return ResContainer.decodedData(rf.getDeobfName(), os.toByteArray());
+			} catch (Exception e) {
+				LOG.error("Failed to decode 9-patch png image, path: {}", name, e);
+			}
+		}
+		return ResContainer.resourceFileLink(rf);
+	}
+
+	private void loadFile(List<ResourceFile> list, File file) {
+		if (file == null || file.isDirectory()) {
+			return;
+		}
+		if (FileUtils.isZipFile(file)) {
+			ZipSecurity.visitZipEntries(file, (zipFile, entry) -> {
+				addEntry(list, file, entry);
+				return null;
+			});
+		} else {
+			addResourceFile(list, file);
+		}
+	}
+
+	private void addResourceFile(List<ResourceFile> list, File file) {
+		String name = file.getAbsolutePath();
+		ResourceType type = ResourceType.getFileType(name);
+		ResourceFile rf = ResourceFile.createResourceFile(jadxRef, name, type);
+		if (rf != null) {
+			list.add(rf);
+		}
+	}
+
+	private void addEntry(List<ResourceFile> list, File zipFile, ZipEntry entry) {
+		if (entry.isDirectory()) {
+			return;
+		}
+		String name = entry.getName();
+		ResourceType type = ResourceType.getFileType(name);
+		ResourceFile rf = ResourceFile.createResourceFile(jadxRef, name, type);
+		if (rf != null) {
+			rf.setZipRef(new ZipRef(zipFile, name));
+			list.add(rf);
+		}
+	}
+
+	public static ICodeInfo loadToCodeWriter(InputStream is) throws IOException {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream(READ_BUFFER_SIZE);
+		copyStream(is, baos);
+		return new SimpleCodeInfo(baos.toString("UTF-8"));
+	}
+}

jadx-core/src/main/java/jadx/api/data/CodeRefType.java

@@ -0,0 +1,8 @@
+package jadx.api.data;
+
+public enum CodeRefType {
+	MTH_ARG,
+	VAR,
+	CATCH,
+	INSN,
+}

jadx-core/src/main/java/jadx/api/data/ICodeComment.java

@@ -0,0 +1,13 @@
+package jadx.api.data;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface ICodeComment extends Comparable<ICodeComment> {
+
+	IJavaNodeRef getNodeRef();
+
+	@Nullable
+	IJavaCodeRef getCodeRef();
+
+	String getComment();
+}

jadx-core/src/main/java/jadx/api/data/ICodeData.java

@@ -0,0 +1,10 @@
+package jadx.api.data;
+
+import java.util.List;
+
+public interface ICodeData {
+
+	List<ICodeComment> getComments();
+
+	List<ICodeRename> getRenames();
+}

jadx-core/src/main/java/jadx/api/data/ICodeRename.java

@@ -0,0 +1,13 @@
+package jadx.api.data;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface ICodeRename extends Comparable<ICodeRename> {
+
+	IJavaNodeRef getNodeRef();
+
+	@Nullable
+	IJavaCodeRef getCodeRef();
+
+	String getNewName();
+}

jadx-core/src/main/java/jadx/api/data/IJavaCodeRef.java

@@ -0,0 +1,15 @@
+package jadx.api.data;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface IJavaCodeRef extends Comparable<IJavaCodeRef> {
+
+	CodeRefType getAttachType();
+
+	int getIndex();
+
+	@Override
+	default int compareTo(@NotNull IJavaCodeRef o) {
+		return Integer.compare(getIndex(), o.getIndex());
+	}
+}

jadx-core/src/main/java/jadx/api/data/IJavaNodeRef.java

@@ -0,0 +1,14 @@
+package jadx.api.data;
+
+public interface IJavaNodeRef extends Comparable<IJavaNodeRef> {
+
+	enum RefType {
+		CLASS, FIELD, METHOD, PKG
+	}
+
+	RefType getType();
+
+	String getDeclaringClass();
+
+	String getShortId();
+}

jadx-core/src/main/java/jadx/api/data/annotations/ICodeRawOffset.java

@@ -0,0 +1,5 @@
+package jadx.api.data.annotations;
+
+public interface ICodeRawOffset {
+	int getOffset();
+}

jadx-core/src/main/java/jadx/api/data/annotations/InsnCodeOffset.java

@@ -0,0 +1,52 @@
+package jadx.api.data.annotations;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeWriter;
+import jadx.core.dex.nodes.InsnNode;
+
+public class InsnCodeOffset implements ICodeRawOffset {
+
+	public static void attach(ICodeWriter code, InsnNode insn) {
+		if (insn == null) {
+			return;
+		}
+		if (code.isMetadataSupported()) {
+			InsnCodeOffset ann = from(insn);
+			if (ann != null) {
+				code.attachLineAnnotation(ann);
+			}
+		}
+	}
+
+	public static void attach(ICodeWriter code, int offset) {
+		if (offset >= 0 && code.isMetadataSupported()) {
+			code.attachLineAnnotation(new InsnCodeOffset(offset));
+		}
+	}
+
+	@Nullable
+	public static InsnCodeOffset from(InsnNode insn) {
+		int offset = insn.getOffset();
+		if (offset < 0) {
+			return null;
+		}
+		return new InsnCodeOffset(offset);
+	}
+
+	private final int offset;
+
+	public InsnCodeOffset(int offset) {
+		this.offset = offset;
+	}
+
+	@Override
+	public int getOffset() {
+		return offset;
+	}
+
+	@Override
+	public String toString() {
+		return "offset=" + offset;
+	}
+}

jadx-core/src/main/java/jadx/api/data/annotations/VarDeclareRef.java

@@ -0,0 +1,57 @@
+package jadx.api.data.annotations;
+
+import jadx.core.dex.attributes.ILineAttributeNode;
+import jadx.core.dex.instructions.args.CodeVar;
+import jadx.core.dex.nodes.MethodNode;
+
+public class VarDeclareRef extends VarRef implements ILineAttributeNode {
+
+	public static VarDeclareRef get(MethodNode mth, CodeVar codeVar) {
+		VarDeclareRef ref = new VarDeclareRef(mth, codeVar);
+		codeVar.setCachedVarRef(ref);
+		return ref;
+	}
+
+	private int sourceLine;
+	private int decompiledLine;
+	private int defPosition;
+
+	private VarDeclareRef(MethodNode mth, CodeVar codeVar) {
+		super(mth, codeVar.getAnySsaVar());
+	}
+
+	@Override
+	public int getSourceLine() {
+		return sourceLine;
+	}
+
+	@Override
+	public void setSourceLine(int sourceLine) {
+		this.sourceLine = sourceLine;
+	}
+
+	@Override
+	public int getDecompiledLine() {
+		return decompiledLine;
+	}
+
+	@Override
+	public void setDecompiledLine(int decompiledLine) {
+		this.decompiledLine = decompiledLine;
+	}
+
+	@Override
+	public int getDefPosition() {
+		return defPosition;
+	}
+
+	@Override
+	public void setDefPosition(int pos) {
+		this.defPosition = pos;
+	}
+
+	@Override
+	public String toString() {
+		return "VarDeclareRef{r" + getReg() + 'v' + getSsa() + '}';
+	}
+}

jadx-core/src/main/java/jadx/api/data/annotations/VarRef.java

@@ -0,0 +1,98 @@
+package jadx.api.data.annotations;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.instructions.args.CodeVar;
+import jadx.core.dex.instructions.args.RegisterArg;
+import jadx.core.dex.instructions.args.SSAVar;
+import jadx.core.dex.nodes.MethodNode;
+
+public class VarRef {
+
+	@Nullable
+	public static VarRef get(MethodNode mth, RegisterArg reg) {
+		SSAVar ssaVar = reg.getSVar();
+		if (ssaVar == null) {
+			return null;
+		}
+		CodeVar codeVar = ssaVar.getCodeVar();
+		VarRef cachedVarRef = codeVar.getCachedVarRef();
+		if (cachedVarRef != null) {
+			if (cachedVarRef.getName() == null) {
+				cachedVarRef.setName(codeVar.getName());
+			}
+			return cachedVarRef;
+		}
+		VarRef newVarRef = new VarRef(mth, ssaVar);
+		codeVar.setCachedVarRef(newVarRef);
+		return newVarRef;
+	}
+
+	private final MethodNode mth;
+	private final int reg;
+	private final int ssa;
+	private final ArgType type;
+	private String name;
+
+	protected VarRef(MethodNode mth, SSAVar ssaVar) {
+		this(mth, ssaVar.getRegNum(), ssaVar.getVersion(),
+				ssaVar.getCodeVar().getType(), ssaVar.getCodeVar().getName());
+	}
+
+	private VarRef(MethodNode mth, int reg, int ssa, ArgType type, String name) {
+		this.mth = mth;
+		this.reg = reg;
+		this.ssa = ssa;
+		this.type = type;
+		this.name = name;
+	}
+
+	public MethodNode getMth() {
+		return mth;
+	}
+
+	public int getReg() {
+		return reg;
+	}
+
+	public int getSsa() {
+		return ssa;
+	}
+
+	public ArgType getType() {
+		return type;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof VarRef)) {
+			return false;
+		}
+		VarRef other = (VarRef) o;
+		return getReg() == other.getReg()
+				&& getSsa() == other.getSsa()
+				&& getMth().equals(other.getMth());
+	}
+
+	@Override
+	public int hashCode() {
+		return 31 * getReg() + getSsa();
+	}
+
+	@Override
+	public String toString() {
+		return "VarUseRef{r" + reg + 'v' + ssa + '}';
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxCodeComment.java

@@ -0,0 +1,78 @@
+package jadx.api.data.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.data.ICodeComment;
+import jadx.api.data.IJavaCodeRef;
+import jadx.api.data.IJavaNodeRef;
+
+public class JadxCodeComment implements ICodeComment {
+
+	private IJavaNodeRef nodeRef;
+	@Nullable
+	private IJavaCodeRef codeRef;
+	private String comment;
+
+	public JadxCodeComment(IJavaNodeRef nodeRef, String comment) {
+		this(nodeRef, null, comment);
+	}
+
+	public JadxCodeComment(IJavaNodeRef nodeRef, @Nullable IJavaCodeRef codeRef, String comment) {
+		this.nodeRef = nodeRef;
+		this.codeRef = codeRef;
+		this.comment = comment;
+	}
+
+	public JadxCodeComment() {
+		// for json deserialization
+	}
+
+	@Override
+	public IJavaNodeRef getNodeRef() {
+		return nodeRef;
+	}
+
+	public void setNodeRef(IJavaNodeRef nodeRef) {
+		this.nodeRef = nodeRef;
+	}
+
+	@Nullable
+	@Override
+	public IJavaCodeRef getCodeRef() {
+		return codeRef;
+	}
+
+	public void setCodeRef(@Nullable IJavaCodeRef codeRef) {
+		this.codeRef = codeRef;
+	}
+
+	@Override
+	public String getComment() {
+		return comment;
+	}
+
+	public void setComment(String comment) {
+		this.comment = comment;
+	}
+
+	@Override
+	public int compareTo(@NotNull ICodeComment other) {
+		int cmpNodeRef = this.getNodeRef().compareTo(other.getNodeRef());
+		if (cmpNodeRef != 0) {
+			return cmpNodeRef;
+		}
+		if (this.getCodeRef() != null && other.getCodeRef() != null) {
+			return this.getCodeRef().compareTo(other.getCodeRef());
+		}
+		return this.getComment().compareTo(other.getComment());
+	}
+
+	@Override
+	public String toString() {
+		return "JadxCodeComment{" + nodeRef
+				+ ", ref=" + codeRef
+				+ ", comment='" + comment + '\''
+				+ '}';
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxCodeData.java

@@ -0,0 +1,31 @@
+package jadx.api.data.impl;
+
+import java.util.Collections;
+import java.util.List;
+
+import jadx.api.data.ICodeComment;
+import jadx.api.data.ICodeData;
+import jadx.api.data.ICodeRename;
+
+public class JadxCodeData implements ICodeData {
+	private List<ICodeComment> comments = Collections.emptyList();
+	private List<ICodeRename> renames = Collections.emptyList();
+
+	@Override
+	public List<ICodeComment> getComments() {
+		return comments;
+	}
+
+	public void setComments(List<ICodeComment> comments) {
+		this.comments = comments;
+	}
+
+	@Override
+	public List<ICodeRename> getRenames() {
+		return renames;
+	}
+
+	public void setRenames(List<ICodeRename> renames) {
+		this.renames = renames;
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxCodeRef.java

@@ -0,0 +1,88 @@
+package jadx.api.data.impl;
+
+import jadx.api.JavaVariable;
+import jadx.api.data.CodeRefType;
+import jadx.api.data.IJavaCodeRef;
+import jadx.api.data.annotations.VarRef;
+
+public class JadxCodeRef implements IJavaCodeRef {
+
+	public static JadxCodeRef forInsn(int offset) {
+		return new JadxCodeRef(CodeRefType.INSN, offset);
+	}
+
+	public static JadxCodeRef forMthArg(int argIndex) {
+		return new JadxCodeRef(CodeRefType.MTH_ARG, argIndex);
+	}
+
+	public static JadxCodeRef forVar(int regNum, int ssaVersion) {
+		return new JadxCodeRef(CodeRefType.VAR, regNum << 16 | ssaVersion);
+	}
+
+	public static JadxCodeRef forVar(JavaVariable javaVariable) {
+		return forVar(javaVariable.getReg(), javaVariable.getSsa());
+	}
+
+	public static JadxCodeRef forVar(VarRef varRef) {
+		return forVar(varRef.getReg(), varRef.getSsa());
+	}
+
+	public static JadxCodeRef forCatch(int handlerOffset) {
+		return new JadxCodeRef(CodeRefType.CATCH, handlerOffset);
+	}
+
+	private CodeRefType attachType;
+	private int index;
+
+	public JadxCodeRef(CodeRefType attachType, int index) {
+		this.attachType = attachType;
+		this.index = index;
+	}
+
+	public JadxCodeRef() {
+		// used for json serialization
+	}
+
+	public CodeRefType getAttachType() {
+		return attachType;
+	}
+
+	public void setAttachType(CodeRefType attachType) {
+		this.attachType = attachType;
+	}
+
+	@Override
+	public int getIndex() {
+		return index;
+	}
+
+	public void setIndex(int index) {
+		this.index = index;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof JadxCodeRef)) {
+			return false;
+		}
+		JadxCodeRef other = (JadxCodeRef) o;
+		return getIndex() == other.getIndex()
+				&& getAttachType() == other.getAttachType();
+	}
+
+	@Override
+	public int hashCode() {
+		return 31 * getAttachType().hashCode() + getIndex();
+	}
+
+	@Override
+	public String toString() {
+		return "JadxCodeRef{"
+				+ "attachType=" + attachType
+				+ ", index=" + index
+				+ '}';
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxCodeRename.java

@@ -0,0 +1,88 @@
+package jadx.api.data.impl;
+
+import java.util.Objects;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.data.ICodeRename;
+import jadx.api.data.IJavaCodeRef;
+import jadx.api.data.IJavaNodeRef;
+
+public class JadxCodeRename implements ICodeRename {
+	private IJavaNodeRef nodeRef;
+	@Nullable
+	private IJavaCodeRef codeRef;
+	private String newName;
+
+	public JadxCodeRename(IJavaNodeRef nodeRef, String newName) {
+		this(nodeRef, null, newName);
+	}
+
+	public JadxCodeRename(IJavaNodeRef nodeRef, @Nullable IJavaCodeRef codeRef, String newName) {
+		this.nodeRef = nodeRef;
+		this.codeRef = codeRef;
+		this.newName = newName;
+	}
+
+	public JadxCodeRename() {
+		// used in json serialization
+	}
+
+	@Override
+	public IJavaNodeRef getNodeRef() {
+		return nodeRef;
+	}
+
+	public void setNodeRef(IJavaNodeRef nodeRef) {
+		this.nodeRef = nodeRef;
+	}
+
+	@Override
+	public IJavaCodeRef getCodeRef() {
+		return codeRef;
+	}
+
+	public void setCodeRef(IJavaCodeRef codeRef) {
+		this.codeRef = codeRef;
+	}
+
+	@Override
+	public String getNewName() {
+		return newName;
+	}
+
+	public void setNewName(String newName) {
+		this.newName = newName;
+	}
+
+	@Override
+	public int compareTo(@NotNull ICodeRename other) {
+		int cmpNodeRef = this.getNodeRef().compareTo(other.getNodeRef());
+		if (cmpNodeRef != 0) {
+			return cmpNodeRef;
+		}
+		if (this.getCodeRef() != null && other.getCodeRef() != null) {
+			return this.getCodeRef().compareTo(other.getCodeRef());
+		}
+		return this.getNewName().compareTo(other.getNewName());
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof ICodeRename)) {
+			return false;
+		}
+		ICodeRename other = (ICodeRename) o;
+		return getNodeRef().equals(other.getNodeRef())
+				&& Objects.equals(getCodeRef(), other.getCodeRef());
+	}
+
+	@Override
+	public int hashCode() {
+		return 31 * getNodeRef().hashCode() + Objects.hashCode(getCodeRef());
+	}
+}

jadx-core/src/main/java/jadx/api/data/impl/JadxNodeRef.java

@@ -0,0 +1,144 @@
+package jadx.api.data.impl;
+
+import java.util.Comparator;
+import java.util.Objects;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.JavaClass;
+import jadx.api.JavaField;
+import jadx.api.JavaMethod;
+import jadx.api.JavaNode;
+import jadx.api.data.IJavaNodeRef;
+
+public class JadxNodeRef implements IJavaNodeRef {
+
+	@Nullable
+	public static JadxNodeRef forJavaNode(JavaNode javaNode) {
+		if (javaNode instanceof JavaClass) {
+			return forCls((JavaClass) javaNode);
+		}
+		if (javaNode instanceof JavaMethod) {
+			return forMth((JavaMethod) javaNode);
+		}
+		if (javaNode instanceof JavaField) {
+			return forFld((JavaField) javaNode);
+		}
+		return null;
+	}
+
+	public static JadxNodeRef forCls(JavaClass cls) {
+		return new JadxNodeRef(RefType.CLASS, getClassRefStr(cls), null);
+	}
+
+	public static JadxNodeRef forCls(String clsFullName) {
+		return new JadxNodeRef(RefType.CLASS, clsFullName, null);
+	}
+
+	public static JadxNodeRef forMth(JavaMethod mth) {
+		return new JadxNodeRef(RefType.METHOD,
+				getClassRefStr(mth.getDeclaringClass()),
+				mth.getMethodNode().getMethodInfo().getShortId());
+	}
+
+	public static JadxNodeRef forFld(JavaField fld) {
+		return new JadxNodeRef(RefType.FIELD,
+				getClassRefStr(fld.getDeclaringClass()),
+				fld.getFieldNode().getFieldInfo().getShortId());
+	}
+
+	public static JadxNodeRef forPkg(String pkgFullName) {
+		return new JadxNodeRef(RefType.PKG, pkgFullName, "");
+	}
+
+	private static String getClassRefStr(JavaClass cls) {
+		return cls.getClassNode().getClassInfo().getRawName();
+	}
+
+	private RefType refType;
+	private String declClass;
+	@Nullable
+	private String shortId;
+
+	public JadxNodeRef(RefType refType, String declClass, @Nullable String shortId) {
+		this.refType = refType;
+		this.declClass = declClass;
+		this.shortId = shortId;
+	}
+
+	public JadxNodeRef() {
+		// for json deserialization
+	}
+
+	@Override
+	public RefType getType() {
+		return refType;
+	}
+
+	public void setRefType(RefType refType) {
+		this.refType = refType;
+	}
+
+	@Override
+	public String getDeclaringClass() {
+		return declClass;
+	}
+
+	public void setDeclClass(String declClass) {
+		this.declClass = declClass;
+	}
+
+	@Nullable
+	@Override
+	public String getShortId() {
+		return shortId;
+	}
+
+	public void setShortId(@Nullable String shortId) {
+		this.shortId = shortId;
+	}
+
+	private static final Comparator<IJavaNodeRef> COMPARATOR = Comparator
+			.comparing(IJavaNodeRef::getType)
+			.thenComparing(IJavaNodeRef::getDeclaringClass)
+			.thenComparing(IJavaNodeRef::getShortId);
+
+	@Override
+	public int compareTo(@NotNull IJavaNodeRef other) {
+		return COMPARATOR.compare(this, other);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(refType, declClass, shortId);
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof JadxNodeRef)) {
+			return false;
+		}
+		JadxNodeRef that = (JadxNodeRef) o;
+		return refType == that.refType
+				&& Objects.equals(declClass, that.declClass)
+				&& Objects.equals(shortId, that.shortId);
+	}
+
+	@Override
+	public String toString() {
+		switch (refType) {
+			case CLASS:
+			case PKG:
+				return declClass;
+			case FIELD:
+			case METHOD:
+				return declClass + "->" + shortId;
+			default:
+				return "unknown node ref type";
+		}
+	}
+}

jadx-core/src/main/java/jadx/api/impl/AnnotatedCodeInfo.java

@@ -0,0 +1,43 @@
+package jadx.api.impl;
+
+import java.util.Map;
+
+import jadx.api.CodePosition;
+import jadx.api.ICodeInfo;
+
+public class AnnotatedCodeInfo implements ICodeInfo {
+
+	private final String code;
+	private final Map<Integer, Integer> lineMapping;
+	private final Map<CodePosition, Object> annotations;
+
+	public AnnotatedCodeInfo(ICodeInfo codeInfo) {
+		this(codeInfo.getCodeStr(), codeInfo.getLineMapping(), codeInfo.getAnnotations());
+	}
+
+	public AnnotatedCodeInfo(String code, Map<Integer, Integer> lineMapping, Map<CodePosition, Object> annotations) {
+		this.code = code;
+		this.lineMapping = lineMapping;
+		this.annotations = annotations;
+	}
+
+	@Override
+	public String getCodeStr() {
+		return code;
+	}
+
+	@Override
+	public Map<Integer, Integer> getLineMapping() {
+		return lineMapping;
+	}
+
+	@Override
+	public Map<CodePosition, Object> getAnnotations() {
+		return annotations;
+	}
+
+	@Override
+	public String toString() {
+		return code;
+	}
+}

jadx-core/src/main/java/jadx/api/impl/AnnotatedCodeWriter.java

@@ -0,0 +1,192 @@
+package jadx.api.impl;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+import jadx.api.CodePosition;
+import jadx.api.ICodeInfo;
+import jadx.api.ICodeWriter;
+import jadx.api.JadxArgs;
+import jadx.core.dex.attributes.ILineAttributeNode;
+import jadx.core.utils.StringUtils;
+
+public class AnnotatedCodeWriter extends SimpleCodeWriter implements ICodeWriter {
+
+	private int line = 1;
+	private int offset;
+	private Map<CodePosition, Object> annotations = Collections.emptyMap();
+	private Map<Integer, Integer> lineMap = Collections.emptyMap();
+
+	public AnnotatedCodeWriter() {
+	}
+
+	public AnnotatedCodeWriter(JadxArgs args) {
+		super(args);
+	}
+
+	@Override
+	public boolean isMetadataSupported() {
+		return true;
+	}
+
+	@Override
+	public AnnotatedCodeWriter addMultiLine(String str) {
+		if (str.contains(NL)) {
+			buf.append(str.replace(NL, NL + indentStr));
+			line += StringUtils.countMatches(str, NL);
+			offset = 0;
+		} else {
+			buf.append(str);
+		}
+		return this;
+	}
+
+	@Override
+	public AnnotatedCodeWriter add(String str) {
+		buf.append(str);
+		offset += str.length();
+		return this;
+	}
+
+	@Override
+	public AnnotatedCodeWriter add(char c) {
+		buf.append(c);
+		offset++;
+		return this;
+	}
+
+	@Override
+	public ICodeWriter add(ICodeWriter cw) {
+		if ((!(cw instanceof AnnotatedCodeWriter))) {
+			buf.append(cw.getCodeStr());
+			return this;
+		}
+		AnnotatedCodeWriter code = ((AnnotatedCodeWriter) cw);
+		line--;
+		int startLine = line;
+		int startPos = getLength();
+		for (Map.Entry<CodePosition, Object> entry : code.annotations.entrySet()) {
+			CodePosition codePos = entry.getKey();
+			int newLine = startLine + codePos.getLine();
+			int newPos = startPos + codePos.getPos();
+			attachAnnotation(entry.getValue(), new CodePosition(newLine, codePos.getOffset(), newPos));
+		}
+		for (Map.Entry<Integer, Integer> entry : code.lineMap.entrySet()) {
+			attachSourceLine(line + entry.getKey(), entry.getValue());
+		}
+		line += code.line;
+		offset = code.offset;
+		buf.append(code.buf);
+		return this;
+	}
+
+	@Override
+	protected void addLine() {
+		buf.append(NL);
+		line++;
+		offset = 0;
+	}
+
+	@Override
+	protected AnnotatedCodeWriter addLineIndent() {
+		buf.append(indentStr);
+		offset += indentStr.length();
+		return this;
+	}
+
+	@Override
+	public int getLine() {
+		return line;
+	}
+
+	private static final class DefinitionWrapper {
+		private final ILineAttributeNode node;
+
+		private DefinitionWrapper(ILineAttributeNode node) {
+			this.node = node;
+		}
+
+		public ILineAttributeNode getNode() {
+			return node;
+		}
+	}
+
+	@Override
+	public void attachDefinition(ILineAttributeNode obj) {
+		if (obj == null) {
+			return;
+		}
+		attachAnnotation(obj);
+		attachAnnotation(new DefinitionWrapper(obj), new CodePosition(line, offset, getLength()));
+	}
+
+	@Override
+	public void attachAnnotation(Object obj) {
+		if (obj == null) {
+			return;
+		}
+		attachAnnotation(obj, new CodePosition(line, offset + 1, getLength()));
+	}
+
+	@Override
+	public void attachLineAnnotation(Object obj) {
+		if (obj == null) {
+			return;
+		}
+		attachAnnotation(obj, new CodePosition(line, 0, getLength() - offset));
+	}
+
+	private void attachAnnotation(Object obj, CodePosition pos) {
+		if (annotations.isEmpty()) {
+			annotations = new HashMap<>();
+		}
+		annotations.put(pos, obj);
+	}
+
+	@Override
+	public void attachSourceLine(int sourceLine) {
+		if (sourceLine == 0) {
+			return;
+		}
+		attachSourceLine(line, sourceLine);
+	}
+
+	private void attachSourceLine(int decompiledLine, int sourceLine) {
+		if (lineMap.isEmpty()) {
+			lineMap = new TreeMap<>();
+		}
+		lineMap.put(decompiledLine, sourceLine);
+	}
+
+	@Override
+	public ICodeInfo finish() {
+		removeFirstEmptyLine();
+		processDefinitionAnnotations();
+		String code = buf.toString();
+		buf = null;
+		return new AnnotatedCodeInfo(code, lineMap, annotations);
+	}
+
+	@Override
+	public Map<CodePosition, Object> getRawAnnotations() {
+		return annotations;
+	}
+
+	private void processDefinitionAnnotations() {
+		if (!annotations.isEmpty()) {
+			annotations.entrySet().removeIf(entry -> {
+				Object v = entry.getValue();
+				if (v instanceof DefinitionWrapper) {
+					ILineAttributeNode l = ((DefinitionWrapper) v).getNode();
+					CodePosition codePos = entry.getKey();
+					l.setDecompiledLine(codePos.getLine());
+					l.setDefPosition(codePos.getPos());
+					return true;
+				}
+				return false;
+			});
+		}
+	}
+}

jadx-core/src/main/java/jadx/api/impl/InMemoryCodeCache.java

@@ -0,0 +1,34 @@
+package jadx.api.impl;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeCache;
+import jadx.api.ICodeInfo;
+
+public class InMemoryCodeCache implements ICodeCache {
+
+	private final Map<String, ICodeInfo> storage = new ConcurrentHashMap<>();
+
+	@Override
+	public void add(String clsFullName, ICodeInfo codeInfo) {
+		storage.put(clsFullName, codeInfo);
+	}
+
+	@Override
+	public void remove(String clsFullName) {
+		storage.remove(clsFullName);
+	}
+
+	@Override
+	public @Nullable ICodeInfo get(String clsFullName) {
+		return storage.get(clsFullName);
+	}
+
+	@Override
+	public String toString() {
+		return "InMemoryCodeCache: size=" + storage.size();
+	}
+}

jadx-core/src/main/java/jadx/api/impl/NoOpCodeCache.java

@@ -0,0 +1,29 @@
+package jadx.api.impl;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeCache;
+import jadx.api.ICodeInfo;
+
+public class NoOpCodeCache implements ICodeCache {
+
+	@Override
+	public void add(String clsFullName, ICodeInfo codeInfo) {
+		// do nothing
+	}
+
+	@Override
+	public void remove(String clsFullName) {
+		// do nothing
+	}
+
+	@Override
+	public @Nullable ICodeInfo get(String clsFullName) {
+		return null;
+	}
+
+	@Override
+	public String toString() {
+		return "NoOpCodeCache";
+	}
+}

jadx-core/src/main/java/jadx/api/impl/SimpleCodeInfo.java

@@ -0,0 +1,36 @@
+package jadx.api.impl;
+
+import java.util.Collections;
+import java.util.Map;
+
+import jadx.api.CodePosition;
+import jadx.api.ICodeInfo;
+
+public class SimpleCodeInfo implements ICodeInfo {
+
+	private final String code;
+
+	public SimpleCodeInfo(String code) {
+		this.code = code;
+	}
+
+	@Override
+	public String getCodeStr() {
+		return code;
+	}
+
+	@Override
+	public Map<Integer, Integer> getLineMapping() {
+		return Collections.emptyMap();
+	}
+
+	@Override
+	public Map<CodePosition, Object> getAnnotations() {
+		return Collections.emptyMap();
+	}
+
+	@Override
+	public String toString() {
+		return code;
+	}
+}

jadx-core/src/main/java/jadx/api/impl/SimpleCodeWriter.java

@@ -0,0 +1,255 @@
+package jadx.api.impl;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.CodePosition;
+import jadx.api.ICodeInfo;
+import jadx.api.ICodeWriter;
+import jadx.api.JadxArgs;
+import jadx.core.dex.attributes.ILineAttributeNode;
+import jadx.core.utils.Utils;
+
+/**
+ * CodeWriter implementation without meta information support (only strings builder)
+ */
+public class SimpleCodeWriter implements ICodeWriter {
+	private static final Logger LOG = LoggerFactory.getLogger(SimpleCodeWriter.class);
+
+	private static final String[] INDENT_CACHE = {
+			"",
+			INDENT_STR,
+			INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR,
+	};
+
+	protected StringBuilder buf = new StringBuilder();
+	protected String indentStr = "";
+	protected int indent = 0;
+
+	private final boolean insertLineNumbers;
+
+	public SimpleCodeWriter() {
+		this.insertLineNumbers = false;
+	}
+
+	public SimpleCodeWriter(JadxArgs args) {
+		this.insertLineNumbers = args.isInsertDebugLines();
+		if (insertLineNumbers) {
+			incIndent(3);
+			add(indentStr);
+		}
+	}
+
+	@Override
+	public boolean isMetadataSupported() {
+		return false;
+	}
+
+	@Override
+	public SimpleCodeWriter startLine() {
+		addLine();
+		addLineIndent();
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter startLine(char c) {
+		startLine();
+		add(c);
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter startLine(String str) {
+		startLine();
+		add(str);
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter startLineWithNum(int sourceLine) {
+		if (sourceLine == 0) {
+			startLine();
+			return this;
+		}
+		if (this.insertLineNumbers) {
+			newLine();
+			attachSourceLine(sourceLine);
+			int start = getLength();
+			add("/* ").add(Integer.toString(sourceLine)).add(" */ ");
+			int len = getLength() - start;
+			if (indentStr.length() > len) {
+				add(indentStr.substring(len));
+			}
+		} else {
+			startLine();
+			attachSourceLine(sourceLine);
+		}
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter addMultiLine(String str) {
+		if (str.contains(NL)) {
+			buf.append(str.replace(NL, NL + indentStr));
+		} else {
+			buf.append(str);
+		}
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter add(String str) {
+		buf.append(str);
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter add(char c) {
+		buf.append(c);
+		return this;
+	}
+
+	@Override
+	public ICodeWriter add(ICodeWriter cw) {
+		buf.append(cw.getCodeStr());
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter newLine() {
+		addLine();
+		return this;
+	}
+
+	@Override
+	public SimpleCodeWriter addIndent() {
+		add(INDENT_STR);
+		return this;
+	}
+
+	protected void addLine() {
+		buf.append(NL);
+	}
+
+	protected SimpleCodeWriter addLineIndent() {
+		buf.append(indentStr);
+		return this;
+	}
+
+	private void updateIndent() {
+		int curIndent = indent;
+		if (curIndent < INDENT_CACHE.length) {
+			this.indentStr = INDENT_CACHE[curIndent];
+		} else {
+			this.indentStr = Utils.strRepeat(INDENT_STR, curIndent);
+		}
+	}
+
+	@Override
+	public void incIndent() {
+		incIndent(1);
+	}
+
+	@Override
+	public void decIndent() {
+		decIndent(1);
+	}
+
+	private void incIndent(int c) {
+		this.indent += c;
+		updateIndent();
+	}
+
+	private void decIndent(int c) {
+		this.indent -= c;
+		if (this.indent < 0) {
+			LOG.warn("Indent < 0");
+			this.indent = 0;
+		}
+		updateIndent();
+	}
+
+	@Override
+	public int getIndent() {
+		return indent;
+	}
+
+	@Override
+	public void setIndent(int indent) {
+		this.indent = indent;
+		updateIndent();
+	}
+
+	@Override
+	public int getLine() {
+		return 0;
+	}
+
+	@Override
+	public void attachDefinition(ILineAttributeNode obj) {
+		// no op
+	}
+
+	@Override
+	public void attachAnnotation(Object obj) {
+		// no op
+	}
+
+	@Override
+	public void attachLineAnnotation(Object obj) {
+		// no op
+	}
+
+	@Override
+	public void attachSourceLine(int sourceLine) {
+		// no op
+	}
+
+	@Override
+	public ICodeInfo finish() {
+		removeFirstEmptyLine();
+		String code = buf.toString();
+		buf = null;
+		return new SimpleCodeInfo(code);
+	}
+
+	protected void removeFirstEmptyLine() {
+		int len = NL.length();
+		if (buf.length() > len && buf.substring(0, len).equals(NL)) {
+			buf.delete(0, len);
+		}
+	}
+
+	@Override
+	public int getLength() {
+		return buf.length();
+	}
+
+	@Override
+	public StringBuilder getRawBuf() {
+		return buf;
+	}
+
+	@Override
+	public Map<CodePosition, Object> getRawAnnotations() {
+		return Collections.emptyMap();
+	}
+
+	@Override
+	public String getCodeStr() {
+		removeFirstEmptyLine();
+		return buf.toString();
+	}
+
+	@Override
+	public String toString() {
+		return getCodeStr();
+	}
+}

jadx-core/src/main/java/jadx/core/Consts.java

@@ -1,24 +1,28 @@
 package jadx.core;
 
 public class Consts {
-	public static final String JADX_VERSION = Jadx.getVersion();
-
 	public static final boolean DEBUG = false;
+	public static final boolean DEBUG_WITH_ERRORS = false; // TODO: fix errors
+	public static final boolean DEBUG_USAGE = false;
+	public static final boolean DEBUG_TYPE_INFERENCE = false;
+	public static final boolean DEBUG_OVERLOADED_CASTS = false;
+	public static final boolean DEBUG_EXC_HANDLERS = false;
 
 	public static final String CLASS_OBJECT = "java.lang.Object";
 	public static final String CLASS_STRING = "java.lang.String";
 	public static final String CLASS_CLASS = "java.lang.Class";
 	public static final String CLASS_THROWABLE = "java.lang.Throwable";
+	public static final String CLASS_EXCEPTION = "java.lang.Exception";
 	public static final String CLASS_ENUM = "java.lang.Enum";
 
 	public static final String CLASS_STRING_BUILDER = "java.lang.StringBuilder";
-
-	public static final String DALVIK_ANNOTATION_PKG = "dalvik.annotation.";
-	public static final String DALVIK_SIGNATURE = "dalvik.annotation.Signature";
-	public static final String DALVIK_INNER_CLASS = "dalvik.annotation.InnerClass";
-	public static final String DALVIK_THROWS = "dalvik.annotation.Throws";
-	public static final String DALVIK_ANNOTATION_DEFAULT = "dalvik.annotation.AnnotationDefault";
+	public static final String OVERRIDE_ANNOTATION = "Ljava/lang/Override;";
 
 	public static final String DEFAULT_PACKAGE_NAME = "defpackage";
-	public static final String ANONYMOUS_CLASS_PREFIX = "AnonymousClass_";
+	public static final String ANONYMOUS_CLASS_PREFIX = "AnonymousClass";
+
+	public static final String MTH_TOSTRING_SIGNATURE = "toString()Ljava/lang/String;";
+
+	private Consts() {
+	}
 }

jadx-core/src/main/java/jadx/core/Jadx.java

@@ -1,29 +1,6 @@
 package jadx.core;
 
-import jadx.api.IJadxArgs;
-import jadx.core.codegen.CodeGen;
-import jadx.core.dex.visitors.BlockMakerVisitor;
-import jadx.core.dex.visitors.ClassModifier;
-import jadx.core.dex.visitors.CodeShrinker;
-import jadx.core.dex.visitors.ConstInlinerVisitor;
-import jadx.core.dex.visitors.DotGraphVisitor;
-import jadx.core.dex.visitors.EnumVisitor;
-import jadx.core.dex.visitors.FallbackModeVisitor;
-import jadx.core.dex.visitors.IDexTreeVisitor;
-import jadx.core.dex.visitors.MethodInlinerVisitor;
-import jadx.core.dex.visitors.ModVisitor;
-import jadx.core.dex.visitors.SimplifyVisitor;
-import jadx.core.dex.visitors.regions.CheckRegions;
-import jadx.core.dex.visitors.regions.CleanRegions;
-import jadx.core.dex.visitors.regions.PostRegionVisitor;
-import jadx.core.dex.visitors.regions.ProcessVariables;
-import jadx.core.dex.visitors.regions.RegionMakerVisitor;
-import jadx.core.dex.visitors.typeresolver.FinishTypeResolver;
-import jadx.core.dex.visitors.typeresolver.TypeResolver;
-import jadx.core.utils.Utils;
-
-import java.io.File;
-import java.io.IOException;
+import java.io.InputStream;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Enumeration;
@@ -33,65 +10,182 @@ import java.util.jar.Manifest;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.CommentsLevel;
+import jadx.api.JadxArgs;
+import jadx.core.dex.visitors.AttachCommentsVisitor;
+import jadx.core.dex.visitors.AttachMethodDetails;
+import jadx.core.dex.visitors.AttachTryCatchVisitor;
+import jadx.core.dex.visitors.CheckCode;
+import jadx.core.dex.visitors.ClassModifier;
+import jadx.core.dex.visitors.ConstInlineVisitor;
+import jadx.core.dex.visitors.ConstructorVisitor;
+import jadx.core.dex.visitors.DeboxingVisitor;
+import jadx.core.dex.visitors.DotGraphVisitor;
+import jadx.core.dex.visitors.EnumVisitor;
+import jadx.core.dex.visitors.ExtractFieldInit;
+import jadx.core.dex.visitors.FallbackModeVisitor;
+import jadx.core.dex.visitors.FixAccessModifiers;
+import jadx.core.dex.visitors.GenericTypesVisitor;
+import jadx.core.dex.visitors.IDexTreeVisitor;
+import jadx.core.dex.visitors.InitCodeVariables;
+import jadx.core.dex.visitors.InlineMethods;
+import jadx.core.dex.visitors.MarkMethodsForInline;
+import jadx.core.dex.visitors.MethodInvokeVisitor;
+import jadx.core.dex.visitors.ModVisitor;
+import jadx.core.dex.visitors.MoveInlineVisitor;
+import jadx.core.dex.visitors.OverrideMethodVisitor;
+import jadx.core.dex.visitors.PrepareForCodeGen;
+import jadx.core.dex.visitors.ProcessAnonymous;
+import jadx.core.dex.visitors.ProcessInstructionsVisitor;
+import jadx.core.dex.visitors.ReSugarCode;
+import jadx.core.dex.visitors.ShadowFieldVisitor;
+import jadx.core.dex.visitors.SignatureProcessor;
+import jadx.core.dex.visitors.SimplifyVisitor;
+import jadx.core.dex.visitors.blocks.BlockProcessor;
+import jadx.core.dex.visitors.blocks.BlockSplitter;
+import jadx.core.dex.visitors.debuginfo.DebugInfoApplyVisitor;
+import jadx.core.dex.visitors.debuginfo.DebugInfoAttachVisitor;
+import jadx.core.dex.visitors.finaly.MarkFinallyVisitor;
+import jadx.core.dex.visitors.regions.CheckRegions;
+import jadx.core.dex.visitors.regions.CleanRegions;
+import jadx.core.dex.visitors.regions.IfRegionVisitor;
+import jadx.core.dex.visitors.regions.LoopRegionVisitor;
+import jadx.core.dex.visitors.regions.RegionMakerVisitor;
+import jadx.core.dex.visitors.regions.ReturnVisitor;
+import jadx.core.dex.visitors.regions.variables.ProcessVariables;
+import jadx.core.dex.visitors.rename.CodeRenameVisitor;
+import jadx.core.dex.visitors.rename.RenameVisitor;
+import jadx.core.dex.visitors.shrink.CodeShrinkVisitor;
+import jadx.core.dex.visitors.ssa.SSATransform;
+import jadx.core.dex.visitors.typeinference.TypeInferenceVisitor;
+import jadx.core.dex.visitors.usage.UsageInfoVisitor;
+
 public class Jadx {
 	private static final Logger LOG = LoggerFactory.getLogger(Jadx.class);
 
-	static {
-		if (Consts.DEBUG)
-			LOG.info("debug enabled");
-		if (Jadx.class.desiredAssertionStatus())
-			LOG.info("assertions enabled");
+	private Jadx() {
 	}
 
-	public static List<IDexTreeVisitor> getPassesList(IJadxArgs args, File outDir) {
-		List<IDexTreeVisitor> passes = new ArrayList<IDexTreeVisitor>();
-		if (args.isFallbackMode()) {
-			passes.add(new FallbackModeVisitor());
-		} else {
-			passes.add(new BlockMakerVisitor());
-
-			passes.add(new TypeResolver());
-
-			if (args.isRawCFGOutput())
-				passes.add(new DotGraphVisitor(outDir, false, true));
-
-			passes.add(new ConstInlinerVisitor());
-			passes.add(new FinishTypeResolver());
-
-			passes.add(new ModVisitor());
-			passes.add(new EnumVisitor());
-
-			if (args.isCFGOutput())
-				passes.add(new DotGraphVisitor(outDir, false));
-
-			passes.add(new RegionMakerVisitor());
-			passes.add(new PostRegionVisitor());
-
-			passes.add(new CodeShrinker());
-			passes.add(new SimplifyVisitor());
-			passes.add(new ProcessVariables());
-			passes.add(new CheckRegions());
-			if (args.isCFGOutput())
-				passes.add(new DotGraphVisitor(outDir, true));
-
-			passes.add(new MethodInlinerVisitor());
-			passes.add(new ClassModifier());
-			passes.add(new CleanRegions());
+	static {
+		if (Consts.DEBUG) {
+			LOG.info("debug enabled");
+		}
+	}
+
+	public static List<IDexTreeVisitor> getFallbackPassesList() {
+		List<IDexTreeVisitor> passes = new ArrayList<>();
+		passes.add(new AttachTryCatchVisitor());
+		passes.add(new AttachCommentsVisitor());
+		passes.add(new ProcessInstructionsVisitor());
+		passes.add(new FallbackModeVisitor());
+		return passes;
+	}
+
+	public static List<IDexTreeVisitor> getPreDecompilePassesList() {
+		List<IDexTreeVisitor> passes = new ArrayList<>();
+		passes.add(new SignatureProcessor());
+		passes.add(new OverrideMethodVisitor());
+		passes.add(new RenameVisitor());
+		passes.add(new UsageInfoVisitor());
+		passes.add(new ProcessAnonymous());
+		return passes;
+	}
+
+	public static List<IDexTreeVisitor> getPassesList(JadxArgs args) {
+		if (args.isFallbackMode()) {
+			return getFallbackPassesList();
+		}
+		List<IDexTreeVisitor> passes = new ArrayList<>();
+
+		// instructions IR
+		passes.add(new CheckCode());
+		if (args.isDebugInfo()) {
+			passes.add(new DebugInfoAttachVisitor());
+		}
+		passes.add(new AttachTryCatchVisitor());
+		if (args.getCommentsLevel() != CommentsLevel.NONE) {
+			passes.add(new AttachCommentsVisitor());
+		}
+		passes.add(new AttachMethodDetails());
+		passes.add(new ProcessInstructionsVisitor());
+
+		// blocks IR
+		passes.add(new BlockSplitter());
+		passes.add(new BlockProcessor());
+		if (args.isRawCFGOutput()) {
+			passes.add(DotGraphVisitor.dumpRaw());
+		}
+
+		passes.add(new SSATransform());
+		passes.add(new MoveInlineVisitor());
+		passes.add(new ConstructorVisitor());
+		passes.add(new InitCodeVariables());
+		if (args.isExtractFinally()) {
+			passes.add(new MarkFinallyVisitor());
+		}
+		passes.add(new ConstInlineVisitor());
+		passes.add(new TypeInferenceVisitor());
+		if (args.isDebugInfo()) {
+			passes.add(new DebugInfoApplyVisitor());
+		}
+		passes.add(new CodeRenameVisitor());
+		if (args.isInlineMethods()) {
+			passes.add(new InlineMethods());
+		}
+		passes.add(new GenericTypesVisitor());
+		passes.add(new ShadowFieldVisitor());
+		passes.add(new DeboxingVisitor());
+		passes.add(new ModVisitor());
+		passes.add(new CodeShrinkVisitor());
+		passes.add(new ReSugarCode());
+		if (args.isCfgOutput()) {
+			passes.add(DotGraphVisitor.dump());
+		}
+
+		// regions IR
+		passes.add(new RegionMakerVisitor());
+		passes.add(new IfRegionVisitor());
+		passes.add(new ReturnVisitor());
+		passes.add(new CleanRegions());
+
+		passes.add(new CodeShrinkVisitor());
+		passes.add(new MethodInvokeVisitor());
+		passes.add(new SimplifyVisitor());
+		passes.add(new CheckRegions());
+
+		passes.add(new EnumVisitor());
+		passes.add(new ExtractFieldInit());
+		passes.add(new FixAccessModifiers());
+		passes.add(new ClassModifier());
+		passes.add(new LoopRegionVisitor());
+
+		if (args.isInlineMethods()) {
+			passes.add(new MarkMethodsForInline());
+		}
+		passes.add(new ProcessVariables());
+		passes.add(new PrepareForCodeGen());
+		if (args.isCfgOutput()) {
+			passes.add(DotGraphVisitor.dumpRegions());
 		}
-		passes.add(new CodeGen(args));
 		return passes;
 	}
 
 	public static String getVersion() {
 		try {
-			Enumeration<URL> resources = Utils.class.getClassLoader().getResources("META-INF/MANIFEST.MF");
-			while (resources.hasMoreElements()) {
-				Manifest manifest = new Manifest(resources.nextElement().openStream());
-				String ver = manifest.getMainAttributes().getValue("jadx-version");
-				if (ver != null)
-					return ver;
+			ClassLoader classLoader = Jadx.class.getClassLoader();
+			if (classLoader != null) {
+				Enumeration<URL> resources = classLoader.getResources("META-INF/MANIFEST.MF");
+				while (resources.hasMoreElements()) {
+					try (InputStream is = resources.nextElement().openStream()) {
+						Manifest manifest = new Manifest(is);
+						String ver = manifest.getMainAttributes().getValue("jadx-version");
+						if (ver != null) {
+							return ver;
+						}
+					}
+				}
 			}
-		} catch (IOException e) {
+		} catch (Exception e) {
 			LOG.error("Can't get manifest file", e);
 		}
 		return "dev";

jadx-core/src/main/java/jadx/core/ProcessClass.java

@@ -1,37 +1,123 @@
 package jadx.core;
 
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.visitors.DepthTraverser;
-import jadx.core.dex.visitors.IDexTreeVisitor;
-import jadx.core.utils.exceptions.DecodeException;
-
+import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
-public final class ProcessClass implements Runnable {
-	private static final Logger LOG = LoggerFactory.getLogger(ProcessClass.class);
+import jadx.api.ICodeInfo;
+import jadx.core.codegen.CodeGen;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.LoadStage;
+import jadx.core.dex.visitors.DepthTraversal;
+import jadx.core.dex.visitors.IDexTreeVisitor;
+import jadx.core.utils.exceptions.JadxRuntimeException;
 
-	private final ClassNode cls;
-	private final List<IDexTreeVisitor> passes;
+import static jadx.core.dex.nodes.ProcessState.GENERATED_AND_UNLOADED;
+import static jadx.core.dex.nodes.ProcessState.LOADED;
+import static jadx.core.dex.nodes.ProcessState.NOT_LOADED;
+import static jadx.core.dex.nodes.ProcessState.PROCESS_COMPLETE;
+import static jadx.core.dex.nodes.ProcessState.PROCESS_STARTED;
 
-	public ProcessClass(ClassNode cls, List<IDexTreeVisitor> passes) {
-		this.cls = cls;
-		this.passes = passes;
+public final class ProcessClass {
+
+	private ProcessClass() {
 	}
 
-	@Override
-	public void run() {
-		try {
-			cls.load();
-			for (IDexTreeVisitor visitor : passes) {
-				DepthTraverser.visit(visitor, cls);
+	@Nullable
+	private static ICodeInfo process(ClassNode cls, boolean codegen) {
+		if (!codegen && cls.getState() == PROCESS_COMPLETE) {
+			// nothing to do
+			return null;
+		}
+		synchronized (cls.getClassInfo()) {
+			try {
+				if (cls.contains(AFlag.CLASS_DEEP_RELOAD)) {
+					cls.remove(AFlag.CLASS_DEEP_RELOAD);
+					cls.deepUnload();
+					cls.root().runPreDecompileStageForClass(cls);
+				}
+				if (cls.contains(AFlag.CLASS_UNLOADED)) {
+					cls.remove(AFlag.CLASS_UNLOADED);
+					cls.root().runPreDecompileStageForClass(cls);
+				}
+				if (codegen) {
+					if (cls.getState() == GENERATED_AND_UNLOADED) {
+						// allow to run code generation again
+						cls.setState(NOT_LOADED);
+					}
+					cls.setLoadStage(LoadStage.CODEGEN_STAGE);
+					if (cls.contains(AFlag.RELOAD_AT_CODEGEN_STAGE)) {
+						cls.remove(AFlag.RELOAD_AT_CODEGEN_STAGE);
+						cls.unload();
+					}
+				} else {
+					cls.setLoadStage(LoadStage.PROCESS_STAGE);
+				}
+				if (cls.getState() == NOT_LOADED) {
+					cls.load();
+				}
+				if (cls.getState() == LOADED) {
+					cls.setState(PROCESS_STARTED);
+					for (IDexTreeVisitor visitor : cls.root().getPasses()) {
+						DepthTraversal.visit(visitor, cls);
+					}
+					cls.setState(PROCESS_COMPLETE);
+				}
+				if (codegen) {
+					ICodeInfo code = CodeGen.generate(cls);
+					if (!cls.contains(AFlag.DONT_UNLOAD_CLASS)) {
+						cls.unload();
+						cls.setState(GENERATED_AND_UNLOADED);
+					}
+					return code;
+				}
+				return null;
+			} catch (Throwable e) {
+				if (codegen) {
+					throw e;
+				}
+				cls.addError("Class process error: " + e.getClass().getSimpleName(), e);
+				return null;
 			}
-		} catch (DecodeException e) {
-			LOG.error("Decode exception: " + cls, e);
-		} finally {
-			cls.unload();
+		}
+	}
+
+	@NotNull
+	public static ICodeInfo generateCode(ClassNode cls) {
+		ClassNode topParentClass = cls.getTopParentClass();
+		if (topParentClass != cls) {
+			return generateCode(topParentClass);
+		}
+		try {
+			Set<ClassNode> useIn = new HashSet<>(cls.getUseIn());
+			List<ClassNode> usedInDeps = new ArrayList<>();
+			for (ClassNode depCls : cls.getDependencies()) {
+				if (useIn.contains(depCls)) {
+					// postpone to resolve cross dependencies
+					usedInDeps.add(depCls);
+				} else {
+					process(depCls, false);
+				}
+			}
+			if (!usedInDeps.isEmpty()) {
+				// process current class before its usage
+				process(cls, false);
+				for (ClassNode depCls : usedInDeps) {
+					process(depCls, false);
+				}
+			}
+			ICodeInfo code = process(cls, true);
+			if (code == null) {
+				throw new JadxRuntimeException("Codegen failed");
+			}
+			return code;
+		} catch (Throwable e) {
+			throw new JadxRuntimeException("Failed to generate code for class: " + cls.getFullName(), e);
 		}
 	}
 }

jadx-core/src/main/java/jadx/core/clsp/ClsSet.java

@@ -1,32 +1,44 @@
 package jadx.core.clsp;
 
-import jadx.core.dex.info.ClassInfo;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.RootNode;
-import jadx.core.utils.Utils;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-
+import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 import java.util.zip.ZipOutputStream;
 
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.plugins.utils.ZipSecurity;
+import jadx.core.dex.info.AccessInfo;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.info.MethodInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.exceptions.DecodeException;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+
 /**
  * Classes list for import into classpath graph
  */
@@ -35,175 +47,435 @@ public class ClsSet {
 
 	private static final String CLST_EXTENSION = ".jcst";
 	private static final String CLST_FILENAME = "core" + CLST_EXTENSION;
-	private static final String CLST_PKG_PATH = ClsSet.class.getPackage().getName().replace('.', '/');
+	private static final String CLST_PATH = "/clst/" + CLST_FILENAME;
 
 	private static final String JADX_CLS_SET_HEADER = "jadx-cst";
-	private static final int VERSION = 1;
+	private static final int VERSION = 3;
 
 	private static final String STRING_CHARSET = "US-ASCII";
 
-	private NClass[] classes;
+	private static final ArgType[] EMPTY_ARGTYPE_ARRAY = new ArgType[0];
 
-	public void load(RootNode root) {
+	private final RootNode root;
+
+	public ClsSet(RootNode root) {
+		this.root = root;
+	}
+
+	private enum TypeEnum {
+		WILDCARD,
+		GENERIC,
+		GENERIC_TYPE_VARIABLE,
+		OUTER_GENERIC,
+		OBJECT,
+		ARRAY,
+		PRIMITIVE
+	}
+
+	private ClspClass[] classes;
+
+	public void loadFromClstFile() throws IOException, DecodeException {
+		long startTime = System.currentTimeMillis();
+		try (InputStream input = ClsSet.class.getResourceAsStream(CLST_PATH)) {
+			if (input == null) {
+				throw new JadxRuntimeException("Can't load classpath file: " + CLST_PATH);
+			}
+			load(input);
+		}
+		if (LOG.isDebugEnabled()) {
+			long time = System.currentTimeMillis() - startTime;
+			int methodsCount = Stream.of(classes).mapToInt(clspClass -> clspClass.getMethodsMap().size()).sum();
+			LOG.debug("Clst file loaded in {}ms, classes: {}, methods: {}", time, classes.length, methodsCount);
+		}
+	}
+
+	public void loadFrom(RootNode root) {
 		List<ClassNode> list = root.getClasses(true);
-		Map<String, NClass> names = new HashMap<String, NClass>(list.size());
+		Map<String, ClspClass> names = new HashMap<>(list.size());
 		int k = 0;
 		for (ClassNode cls : list) {
-			String clsRawName = cls.getRawName();
-			if (cls.getAccessFlags().isPublic()) {
-				NClass nClass = new NClass(clsRawName, k);
-				if (names.put(clsRawName, nClass) != null) {
-					throw new JadxRuntimeException("Duplicate class: " + clsRawName);
-				}
-				k++;
-			} else {
-				names.put(clsRawName, null);
+			ArgType clsType = cls.getClassInfo().getType();
+			String clsRawName = clsType.getObject();
+			cls.load();
+			ClspClass nClass = new ClspClass(clsType, k);
+			if (names.put(clsRawName, nClass) != null) {
+				throw new JadxRuntimeException("Duplicate class: " + clsRawName);
 			}
+			k++;
+			nClass.setTypeParameters(cls.getGenericTypeParameters());
+			nClass.setMethods(getMethodsDetails(cls));
 		}
-		classes = new NClass[k];
+		classes = new ClspClass[k];
 		k = 0;
 		for (ClassNode cls : list) {
-			if (cls.getAccessFlags().isPublic()) {
-				NClass nClass = getCls(cls.getRawName(), names);
-				nClass.setParents(makeParentsArray(cls, names));
-				classes[k] = nClass;
-				k++;
+			ClspClass nClass = getCls(cls, names);
+			if (nClass == null) {
+				throw new JadxRuntimeException("Missing class: " + cls);
 			}
+			nClass.setParents(makeParentsArray(cls));
+			classes[k] = nClass;
+			k++;
 		}
 	}
 
-	public static NClass[] makeParentsArray(ClassNode cls, Map<String, NClass> names) {
-		List<NClass> parents = new ArrayList<NClass>(1 + cls.getInterfaces().size());
-		ClassInfo superClass = cls.getSuperClass();
-		if (superClass != null) {
-			NClass c = getCls(superClass.getRawName(), names);
-			if (c != null) {
-				parents.add(c);
-			}
+	private List<ClspMethod> getMethodsDetails(ClassNode cls) {
+		List<MethodNode> methodsList = cls.getMethods();
+		List<ClspMethod> methods = new ArrayList<>(methodsList.size());
+		for (MethodNode mth : methodsList) {
+			processMethodDetails(mth, methods);
 		}
-		for (ClassInfo iface : cls.getInterfaces()) {
-			NClass c = getCls(iface.getRawName(), names);
-			if (c != null) {
-				parents.add(c);
-			}
-		}
-		return parents.toArray(new NClass[parents.size()]);
+		return methods;
 	}
 
-	private static NClass getCls(String fullName, Map<String, NClass> names) {
-		NClass id = names.get(fullName);
-		if (id == null && !names.containsKey(fullName)) {
-			LOG.warn("Class not found: " + fullName);
+	private void processMethodDetails(MethodNode mth, List<ClspMethod> methods) {
+		AccessInfo accessFlags = mth.getAccessFlags();
+		if (accessFlags.isPrivate() || accessFlags.isSynthetic() || accessFlags.isBridge()) {
+			return;
 		}
-		return id;
+		ClspMethod clspMethod = new ClspMethod(mth.getMethodInfo(), mth.getArgTypes(),
+				mth.getReturnType(), mth.getTypeParameters(),
+				mth.getThrows(), accessFlags.rawValue());
+		methods.add(clspMethod);
 	}
 
-	void save(File output) throws IOException {
-		Utils.makeDirsForFile(output);
+	public static ArgType[] makeParentsArray(ClassNode cls) {
+		ArgType superClass = cls.getSuperClass();
+		if (superClass == null) {
+			// cls is java.lang.Object
+			return EMPTY_ARGTYPE_ARRAY;
+		}
+		ArgType[] parents = new ArgType[1 + cls.getInterfaces().size()];
+		parents[0] = superClass;
+		int k = 1;
+		for (ArgType iface : cls.getInterfaces()) {
+			parents[k] = iface;
+			k++;
+		}
+		return parents;
+	}
 
-		BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(output));
-		String outputName = output.getName();
+	private static ClspClass getCls(ClassNode cls, Map<String, ClspClass> names) {
+		return getCls(cls.getRawName(), names);
+	}
+
+	private static ClspClass getCls(ArgType clsType, Map<String, ClspClass> names) {
+		return getCls(clsType.getObject(), names);
+	}
+
+	private static ClspClass getCls(String fullName, Map<String, ClspClass> names) {
+		ClspClass cls = names.get(fullName);
+		if (cls == null) {
+			LOG.debug("Class not found: {}", fullName);
+		}
+		return cls;
+	}
+
+	public void save(Path path) throws IOException {
+		FileUtils.makeDirsForFile(path);
+		String outputName = path.getFileName().toString();
 		if (outputName.endsWith(CLST_EXTENSION)) {
-			save(outputStream);
+			try (BufferedOutputStream outputStream = new BufferedOutputStream(Files.newOutputStream(path))) {
+				save(outputStream);
+			}
 		} else if (outputName.endsWith(".jar")) {
-			ZipOutputStream out = new ZipOutputStream(outputStream);
-			try {
-				out.putNextEntry(new ZipEntry(CLST_PKG_PATH + "/" + CLST_FILENAME));
-				save(out);
-				out.closeEntry();
-			} finally {
-				out.close();
-				outputStream.close();
+			Path temp = FileUtils.createTempFile(".zip");
+			Files.copy(path, temp, StandardCopyOption.REPLACE_EXISTING);
+
+			try (ZipOutputStream out = new ZipOutputStream(Files.newOutputStream(path));
+					ZipInputStream in = new ZipInputStream(Files.newInputStream(temp))) {
+				String clst = CLST_PATH;
+				boolean clstReplaced = false;
+				ZipEntry entry = in.getNextEntry();
+				while (entry != null) {
+					String entryName = entry.getName();
+					ZipEntry copyEntry = new ZipEntry(entryName);
+					copyEntry.setLastModifiedTime(entry.getLastModifiedTime()); // preserve modified time
+					out.putNextEntry(copyEntry);
+					if (entryName.equals(clst)) {
+						save(out);
+						clstReplaced = true;
+					} else {
+						FileUtils.copyStream(in, out);
+					}
+					entry = in.getNextEntry();
+				}
+				if (!clstReplaced) {
+					out.putNextEntry(new ZipEntry(clst));
+					save(out);
+				}
 			}
 		} else {
 			throw new JadxRuntimeException("Unknown file format: " + outputName);
 		}
 	}
 
-	public void save(OutputStream output) throws IOException {
+	private void save(OutputStream output) throws IOException {
 		DataOutputStream out = new DataOutputStream(output);
 		out.writeBytes(JADX_CLS_SET_HEADER);
 		out.writeByte(VERSION);
 
-		LOG.info("Classes count: " + classes.length);
+		Map<String, ClspClass> names = new HashMap<>(classes.length);
 		out.writeInt(classes.length);
-		for (NClass cls : classes) {
-			writeString(out, cls.getName());
+		for (ClspClass cls : classes) {
+			String clsName = cls.getName();
+			writeString(out, clsName);
+			names.put(clsName, cls);
 		}
-		for (NClass cls : classes) {
-			NClass[] parents = cls.getParents();
-			out.writeByte(parents.length);
-			for (NClass parent : parents) {
-				out.writeInt(parent.getId());
+		for (ClspClass cls : classes) {
+			writeArgTypesArray(out, cls.getParents(), names);
+			writeArgTypesList(out, cls.getTypeParameters(), names);
+			List<ClspMethod> methods = cls.getSortedMethodsList();
+			out.writeShort(methods.size());
+			for (ClspMethod method : methods) {
+				writeMethod(out, method, names);
+			}
+		}
+		int methodsCount = Stream.of(classes).mapToInt(c -> c.getMethodsMap().size()).sum();
+		LOG.info("Classes: {}, methods: {}, file size: {} bytes", classes.length, methodsCount, out.size());
+	}
+
+	private static void writeMethod(DataOutputStream out, ClspMethod method, Map<String, ClspClass> names) throws IOException {
+		MethodInfo methodInfo = method.getMethodInfo();
+		writeString(out, methodInfo.getName());
+		writeArgTypesList(out, methodInfo.getArgumentsTypes(), names);
+		writeArgType(out, methodInfo.getReturnType(), names);
+
+		writeArgTypesList(out, method.containsGenericArgs() ? method.getArgTypes() : Collections.emptyList(), names);
+		writeArgType(out, method.getReturnType(), names);
+		writeArgTypesList(out, method.getTypeParameters(), names);
+		out.writeInt(method.getRawAccessFlags());
+		writeArgTypesList(out, method.getThrows(), names);
+	}
+
+	private static void writeArgTypesList(DataOutputStream out, List<ArgType> list, Map<String, ClspClass> names) throws IOException {
+		int size = list.size();
+		writeUnsignedByte(out, size);
+		if (size != 0) {
+			for (ArgType type : list) {
+				writeArgType(out, type, names);
 			}
 		}
 	}
 
-	public void load() throws IOException, DecodeException {
-		InputStream input = getClass().getResourceAsStream(CLST_FILENAME);
-		if (input == null) {
-			throw new JadxRuntimeException("Can't load classpath file: " + CLST_FILENAME);
+	private static void writeArgTypesArray(DataOutputStream out, @Nullable ArgType[] arr, Map<String, ClspClass> names) throws IOException {
+		if (arr == null) {
+			out.writeByte(-1);
+			return;
+		}
+		int size = arr.length;
+		out.writeByte(size);
+		if (size != 0) {
+			for (ArgType type : arr) {
+				writeArgType(out, type, names);
+			}
 		}
-		load(input);
 	}
 
-	public void load(File input) throws IOException, DecodeException {
+	private static void writeArgType(DataOutputStream out, ArgType argType, Map<String, ClspClass> names) throws IOException {
+		if (argType == null) {
+			out.writeByte(-1);
+			return;
+		}
+		if (argType.isPrimitive()) {
+			out.writeByte(TypeEnum.PRIMITIVE.ordinal());
+			out.writeByte(argType.getPrimitiveType().getShortName().charAt(0));
+		} else if (argType.getOuterType() != null) {
+			out.writeByte(TypeEnum.OUTER_GENERIC.ordinal());
+			writeArgType(out, argType.getOuterType(), names);
+			writeArgType(out, argType.getInnerType(), names);
+		} else if (argType.getWildcardType() != null) {
+			out.writeByte(TypeEnum.WILDCARD.ordinal());
+			ArgType.WildcardBound bound = argType.getWildcardBound();
+			out.writeByte(bound.getNum());
+			if (bound != ArgType.WildcardBound.UNBOUND) {
+				writeArgType(out, argType.getWildcardType(), names);
+			}
+		} else if (argType.isGeneric()) {
+			out.writeByte(TypeEnum.GENERIC.ordinal());
+			out.writeInt(getCls(argType, names).getId());
+			writeArgTypesList(out, argType.getGenericTypes(), names);
+		} else if (argType.isGenericType()) {
+			out.writeByte(TypeEnum.GENERIC_TYPE_VARIABLE.ordinal());
+			writeString(out, argType.getObject());
+			writeArgTypesList(out, argType.getExtendTypes(), names);
+		} else if (argType.isObject()) {
+			out.writeByte(TypeEnum.OBJECT.ordinal());
+			out.writeInt(getCls(argType, names).getId());
+		} else if (argType.isArray()) {
+			out.writeByte(TypeEnum.ARRAY.ordinal());
+			writeArgType(out, argType.getArrayElement(), names);
+		} else {
+			throw new JadxRuntimeException("Cannot save type: " + argType);
+		}
+	}
+
+	private void load(File input) throws IOException, DecodeException {
 		String name = input.getName();
-		InputStream inputStream = new FileInputStream(input);
 		if (name.endsWith(CLST_EXTENSION)) {
-			load(inputStream);
-		} else if (name.endsWith(".jar")) {
-			ZipInputStream in = new ZipInputStream(inputStream);
-			try {
-				ZipEntry entry = in.getNextEntry();
-				while (entry != null) {
-					if (entry.getName().endsWith(CLST_EXTENSION)) {
-						load(in);
-					}
-					entry = in.getNextEntry();
-				}
-			} finally {
-				in.close();
+			try (InputStream inputStream = new FileInputStream(input)) {
+				load(inputStream);
 			}
+		} else if (name.endsWith(".jar")) {
+			ZipSecurity.readZipEntries(input, (entry, in) -> {
+				if (entry.getName().endsWith(CLST_EXTENSION)) {
+					try {
+						load(in);
+					} catch (Exception e) {
+						throw new JadxRuntimeException("Failed to load jadx class set");
+					}
+				}
+			});
 		} else {
 			throw new JadxRuntimeException("Unknown file format: " + name);
 		}
 	}
 
-	public void load(InputStream input) throws IOException, DecodeException {
-		DataInputStream in = new DataInputStream(input);
-		byte[] header = new byte[JADX_CLS_SET_HEADER.length()];
-		int readHeaderLength = in.read(header);
-		int version = in.readByte();
-		if (readHeaderLength != JADX_CLS_SET_HEADER.length()
-				|| !JADX_CLS_SET_HEADER.equals(new String(header, STRING_CHARSET))
-				|| version != VERSION) {
-			throw new DecodeException("Wrong jadx class set header");
-		}
-		int count = in.readInt();
-		classes = new NClass[count];
-		for (int i = 0; i < count; i++) {
-			String name = readString(in);
-			classes[i] = new NClass(name, i);
-		}
-		for (int i = 0; i < count; i++) {
-			int pCount = in.readByte();
-			NClass[] parents = new NClass[pCount];
-			for (int j = 0; j < pCount; j++) {
-				parents[j] = classes[in.readInt()];
+	private void load(InputStream input) throws IOException, DecodeException {
+		try (DataInputStream in = new DataInputStream(new BufferedInputStream(input))) {
+			byte[] header = new byte[JADX_CLS_SET_HEADER.length()];
+			int readHeaderLength = in.read(header);
+			int version = in.readByte();
+			if (readHeaderLength != JADX_CLS_SET_HEADER.length()
+					|| !JADX_CLS_SET_HEADER.equals(new String(header, STRING_CHARSET))
+					|| version != VERSION) {
+				throw new DecodeException("Wrong jadx class set header");
+			}
+			int clsCount = in.readInt();
+			classes = new ClspClass[clsCount];
+			for (int i = 0; i < clsCount; i++) {
+				String name = readString(in);
+				classes[i] = new ClspClass(ArgType.object(name), i);
+			}
+			for (int i = 0; i < clsCount; i++) {
+				ClspClass nClass = classes[i];
+				ClassInfo clsInfo = ClassInfo.fromType(root, nClass.getClsType());
+				nClass.setParents(readArgTypesArray(in));
+				nClass.setTypeParameters(readArgTypesList(in));
+				nClass.setMethods(readClsMethods(in, clsInfo));
 			}
-			classes[i].setParents(parents);
 		}
 	}
 
-	private void writeString(DataOutputStream out, String name) throws IOException {
+	private List<ClspMethod> readClsMethods(DataInputStream in, ClassInfo clsInfo) throws IOException {
+		int mCount = in.readShort();
+		List<ClspMethod> methods = new ArrayList<>(mCount);
+		for (int j = 0; j < mCount; j++) {
+			methods.add(readMethod(in, clsInfo));
+		}
+		return methods;
+	}
+
+	private ClspMethod readMethod(DataInputStream in, ClassInfo clsInfo) throws IOException {
+		String name = readString(in);
+		List<ArgType> argTypes = readArgTypesList(in);
+		ArgType retType = readArgType(in);
+		List<ArgType> genericArgTypes = readArgTypesList(in);
+		if (genericArgTypes.isEmpty() || Objects.equals(genericArgTypes, argTypes)) {
+			genericArgTypes = argTypes;
+		}
+		ArgType genericRetType = readArgType(in);
+		if (Objects.equals(genericRetType, retType)) {
+			genericRetType = retType;
+		}
+		List<ArgType> typeParameters = readArgTypesList(in);
+		int accFlags = in.readInt();
+		List<ArgType> throwList = readArgTypesList(in);
+		MethodInfo methodInfo = MethodInfo.fromDetails(root, clsInfo, name, argTypes, retType);
+		return new ClspMethod(methodInfo,
+				genericArgTypes, genericRetType,
+				typeParameters, throwList, accFlags);
+	}
+
+	private List<ArgType> readArgTypesList(DataInputStream in) throws IOException {
+		int count = in.readByte();
+		if (count == 0) {
+			return Collections.emptyList();
+		}
+		List<ArgType> list = new ArrayList<>(count);
+		for (int i = 0; i < count; i++) {
+			list.add(readArgType(in));
+		}
+		return list;
+	}
+
+	@Nullable
+	private ArgType[] readArgTypesArray(DataInputStream in) throws IOException {
+		int count = in.readByte();
+		if (count == -1) {
+			return null;
+		}
+		if (count == 0) {
+			return EMPTY_ARGTYPE_ARRAY;
+		}
+		ArgType[] arr = new ArgType[count];
+		for (int i = 0; i < count; i++) {
+			arr[i] = readArgType(in);
+		}
+		return arr;
+	}
+
+	private ArgType readArgType(DataInputStream in) throws IOException {
+		int ordinal = in.readByte();
+		if (ordinal == -1) {
+			return null;
+		}
+		if (ordinal >= TypeEnum.values().length) {
+			throw new JadxRuntimeException("Incorrect ordinal for type enum: " + ordinal);
+		}
+		switch (TypeEnum.values()[ordinal]) {
+			case WILDCARD:
+				ArgType.WildcardBound bound = ArgType.WildcardBound.getByNum(in.readByte());
+				if (bound == ArgType.WildcardBound.UNBOUND) {
+					return ArgType.WILDCARD;
+				}
+				ArgType objType = readArgType(in);
+				return ArgType.wildcard(objType, bound);
+
+			case OUTER_GENERIC:
+				ArgType outerType = readArgType(in);
+				ArgType innerType = readArgType(in);
+				return ArgType.outerGeneric(outerType, innerType);
+
+			case GENERIC:
+				ArgType clsType = classes[in.readInt()].getClsType();
+				return ArgType.generic(clsType, readArgTypesList(in));
+
+			case GENERIC_TYPE_VARIABLE:
+				String typeVar = readString(in);
+				List<ArgType> extendTypes = readArgTypesList(in);
+				return ArgType.genericType(typeVar, extendTypes);
+
+			case OBJECT:
+				return classes[in.readInt()].getClsType();
+
+			case ARRAY:
+				return ArgType.array(readArgType(in));
+
+			case PRIMITIVE:
+				char shortName = (char) in.readByte();
+				return ArgType.parse(shortName);
+
+			default:
+				throw new JadxRuntimeException("Unsupported Arg Type: " + ordinal);
+		}
+	}
+
+	private static void writeString(DataOutputStream out, String name) throws IOException {
 		byte[] bytes = name.getBytes(STRING_CHARSET);
-		out.writeByte(bytes.length);
+		int len = bytes.length;
+		if (len >= 0xFF) {
+			throw new JadxRuntimeException("String is too long: " + name);
+		}
+		writeUnsignedByte(out, bytes.length);
 		out.write(bytes);
 	}
 
 	private static String readString(DataInputStream in) throws IOException {
-		int len = in.readByte();
+		int len = readUnsignedByte(in);
+		return readString(in, len);
+	}
+
+	private static String readString(DataInputStream in, int len) throws IOException {
 		byte[] bytes = new byte[len];
 		int count = in.read(bytes);
 		while (count != len) {
@@ -217,12 +489,23 @@ public class ClsSet {
 		return new String(bytes, STRING_CHARSET);
 	}
 
+	private static void writeUnsignedByte(DataOutputStream out, int value) throws IOException {
+		if (value < 0 || value >= 0xFF) {
+			throw new JadxRuntimeException("Unsigned byte value is too big: " + value);
+		}
+		out.writeByte(value);
+	}
+
+	private static int readUnsignedByte(DataInputStream in) throws IOException {
+		return ((int) in.readByte()) & 0xFF;
+	}
+
 	public int getClassesCount() {
 		return classes.length;
 	}
 
-	public void addToMap(Map<String, NClass> nameMap) {
-		for (NClass cls : classes) {
+	public void addToMap(Map<String, ClspClass> nameMap) {
+		for (ClspClass cls : classes) {
 			nameMap.put(cls.getName(), cls);
 		}
 	}

jadx-core/src/main/java/jadx/core/clsp/ClspClass.java

@@ -0,0 +1,100 @@
+package jadx.core.clsp;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import jadx.core.dex.instructions.args.ArgType;
+
+/**
+ * Class node in classpath graph
+ */
+public class ClspClass {
+
+	private final ArgType clsType;
+	private final int id;
+	private ArgType[] parents;
+	private Map<String, ClspMethod> methodsMap = Collections.emptyMap();
+	private List<ArgType> typeParameters = Collections.emptyList();
+
+	public ClspClass(ArgType clsType, int id) {
+		this.clsType = clsType;
+		this.id = id;
+	}
+
+	public String getName() {
+		return clsType.getObject();
+	}
+
+	public ArgType getClsType() {
+		return clsType;
+	}
+
+	public int getId() {
+		return id;
+	}
+
+	public ArgType[] getParents() {
+		return parents;
+	}
+
+	public void setParents(ArgType[] parents) {
+		this.parents = parents;
+	}
+
+	public Map<String, ClspMethod> getMethodsMap() {
+		return methodsMap;
+	}
+
+	public List<ClspMethod> getSortedMethodsList() {
+		List<ClspMethod> list = new ArrayList<>(methodsMap.size());
+		list.addAll(methodsMap.values());
+		Collections.sort(list);
+		return list;
+	}
+
+	public void setMethodsMap(Map<String, ClspMethod> methodsMap) {
+		this.methodsMap = Objects.requireNonNull(methodsMap);
+	}
+
+	public void setMethods(List<ClspMethod> methods) {
+		Map<String, ClspMethod> map = new HashMap<>(methods.size());
+		for (ClspMethod mth : methods) {
+			map.put(mth.getMethodInfo().getShortId(), mth);
+		}
+		setMethodsMap(map);
+	}
+
+	public List<ArgType> getTypeParameters() {
+		return typeParameters;
+	}
+
+	public void setTypeParameters(List<ArgType> typeParameters) {
+		this.typeParameters = typeParameters;
+	}
+
+	@Override
+	public int hashCode() {
+		return clsType.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
+		ClspClass nClass = (ClspClass) o;
+		return clsType.equals(nClass.clsType);
+	}
+
+	@Override
+	public String toString() {
+		return clsType.toString();
+	}
+}

jadx-core/src/main/java/jadx/core/clsp/ClspGraph.java

@@ -1,38 +1,52 @@
 package jadx.core.clsp;
 
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.WeakHashMap;
 
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.core.dex.info.MethodInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.IMethodDetails;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.exceptions.DecodeException;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
 /**
- * Classes hierarchy graph
+ * Classes hierarchy graph with methods additional info
  */
 public class ClspGraph {
 	private static final Logger LOG = LoggerFactory.getLogger(ClspGraph.class);
 
-	private final Map<String, Set<String>> ancestorCache = new WeakHashMap<String, Set<String>>();
-	private Map<String, NClass> nameMap;
+	private final RootNode root;
+	private Map<String, ClspClass> nameMap;
+	private Map<String, Set<String>> superTypesCache;
+	private Map<String, List<String>> implementsCache;
+
+	private final Set<String> missingClasses = new HashSet<>();
+
+	public ClspGraph(RootNode rootNode) {
+		this.root = rootNode;
+	}
 
 	public void load() throws IOException, DecodeException {
-		ClsSet set = new ClsSet();
-		set.load();
+		ClsSet set = new ClsSet(root);
+		set.loadFromClstFile();
 		addClasspath(set);
 	}
 
 	public void addClasspath(ClsSet set) {
 		if (nameMap == null) {
-			nameMap = new HashMap<String, NClass>(set.getClassesCount());
+			nameMap = new HashMap<>(set.getClassesCount());
 			set.addToMap(nameMap);
 		} else {
 			throw new JadxRuntimeException("Classpath already loaded");
@@ -43,71 +57,177 @@ public class ClspGraph {
 		if (nameMap == null) {
 			throw new JadxRuntimeException("Classpath must be loaded first");
 		}
-		int size = classes.size();
-		NClass[] nClasses = new NClass[size];
-		for (int i = 0; i < size; i++) {
-			ClassNode cls = classes.get(i);
-			NClass nClass = new NClass(cls.getRawName(), -1);
-			nClasses[i] = nClass;
-			nameMap.put(cls.getRawName(), nClass);
-		}
-		for (int i = 0; i < size; i++) {
-			nClasses[i].setParents(ClsSet.makeParentsArray(classes.get(i), nameMap));
+		for (ClassNode cls : classes) {
+			addClass(cls);
 		}
 	}
 
+	public void initCache() {
+		fillSuperTypesCache();
+		fillImplementsCache();
+	}
+
+	public boolean isClsKnown(String fullName) {
+		return nameMap.containsKey(fullName);
+	}
+
+	public ClspClass getClsDetails(ArgType type) {
+		return nameMap.get(type.getObject());
+	}
+
+	@Nullable
+	public IMethodDetails getMethodDetails(MethodInfo methodInfo) {
+		ClspClass cls = nameMap.get(methodInfo.getDeclClass().getRawName());
+		if (cls == null) {
+			return null;
+		}
+		ClspMethod clspMethod = getMethodFromClass(cls, methodInfo);
+		if (clspMethod != null) {
+			return clspMethod;
+		}
+		// deep search
+		for (ArgType parent : cls.getParents()) {
+			ClspClass clspParent = getClspClass(parent);
+			if (clspParent != null) {
+				ClspMethod methodFromParent = getMethodFromClass(clspParent, methodInfo);
+				if (methodFromParent != null) {
+					return methodFromParent;
+				}
+			}
+		}
+		// unknown method
+		return new SimpleMethodDetails(methodInfo);
+	}
+
+	private ClspMethod getMethodFromClass(ClspClass cls, MethodInfo methodInfo) {
+		return cls.getMethodsMap().get(methodInfo.getShortId());
+	}
+
+	private void addClass(ClassNode cls) {
+		ArgType clsType = cls.getClassInfo().getType();
+		String rawName = clsType.getObject();
+		ClspClass clspClass = new ClspClass(clsType, -1);
+		clspClass.setParents(ClsSet.makeParentsArray(cls));
+		nameMap.put(rawName, clspClass);
+	}
+
+	/**
+	 * @return {@code clsName} instanceof {@code implClsName}
+	 */
 	public boolean isImplements(String clsName, String implClsName) {
-		Set<String> anc = getAncestors(clsName);
+		Set<String> anc = getSuperTypes(clsName);
 		return anc.contains(implClsName);
 	}
 
+	public List<String> getImplementations(String clsName) {
+		List<String> list = implementsCache.get(clsName);
+		return list == null ? Collections.emptyList() : list;
+	}
+
+	private void fillImplementsCache() {
+		Map<String, List<String>> map = new HashMap<>(nameMap.size());
+		List<String> classes = new ArrayList<>(nameMap.keySet());
+		Collections.sort(classes);
+		for (String cls : classes) {
+			for (String st : getSuperTypes(cls)) {
+				map.computeIfAbsent(st, v -> new ArrayList<>()).add(cls);
+			}
+		}
+		implementsCache = map;
+	}
+
 	public String getCommonAncestor(String clsName, String implClsName) {
+		if (clsName.equals(implClsName)) {
+			return clsName;
+		}
+		ClspClass cls = nameMap.get(implClsName);
+		if (cls == null) {
+			missingClasses.add(clsName);
+			return null;
+		}
 		if (isImplements(clsName, implClsName)) {
 			return implClsName;
 		}
-		Set<String> anc = getAncestors(clsName);
-		NClass cls = nameMap.get(implClsName);
-		if (cls != null) {
-			return searchCommonParent(anc, cls);
-		} else {
-			LOG.debug("Missing class: {}", implClsName);
-			return null;
-		}
+		Set<String> anc = getSuperTypes(clsName);
+		return searchCommonParent(anc, cls);
 	}
 
-	private String searchCommonParent(Set<String> anc, NClass cls) {
-		for (NClass p : cls.getParents()) {
-			String name = p.getName();
+	private String searchCommonParent(Set<String> anc, ClspClass cls) {
+		for (ArgType p : cls.getParents()) {
+			String name = p.getObject();
 			if (anc.contains(name)) {
 				return name;
-			} else {
-				String r = searchCommonParent(anc, p);
-				if (r != null)
+			}
+			ClspClass nCls = getClspClass(p);
+			if (nCls != null) {
+				String r = searchCommonParent(anc, nCls);
+				if (r != null) {
 					return r;
+				}
 			}
 		}
 		return null;
 	}
 
-	private Set<String> getAncestors(String clsName) {
-		Set<String> result = ancestorCache.get(clsName);
-		if (result == null) {
-			result = new HashSet<String>();
-			ancestorCache.put(clsName, result);
-			NClass cls = nameMap.get(clsName);
-			if (cls != null) {
-				addAncestorsNames(cls, result);
-			} else {
-				LOG.debug("Missing class: {}", clsName);
-			}
-		}
-		return result;
+	public Set<String> getSuperTypes(String clsName) {
+		Set<String> result = superTypesCache.get(clsName);
+		return result == null ? Collections.emptySet() : result;
 	}
 
-	private void addAncestorsNames(NClass cls, Set<String> result) {
-		result.add(cls.getName());
-		for (NClass p : cls.getParents()) {
-			addAncestorsNames(p, result);
+	private void fillSuperTypesCache() {
+		Map<String, Set<String>> map = new HashMap<>(nameMap.size());
+		Set<String> tmpSet = new HashSet<>();
+		for (Map.Entry<String, ClspClass> entry : nameMap.entrySet()) {
+			ClspClass cls = entry.getValue();
+			tmpSet.clear();
+			addSuperTypes(cls, tmpSet);
+			Set<String> result;
+			if (tmpSet.isEmpty()) {
+				result = Collections.emptySet();
+			} else {
+				result = new HashSet<>(tmpSet);
+			}
+			map.put(cls.getName(), result);
+		}
+		superTypesCache = map;
+	}
+
+	private void addSuperTypes(ClspClass cls, Set<String> result) {
+		for (ArgType parentType : cls.getParents()) {
+			if (parentType == null) {
+				continue;
+			}
+			ClspClass parentCls = getClspClass(parentType);
+			if (parentCls != null) {
+				boolean isNew = result.add(parentCls.getName());
+				if (isNew) {
+					addSuperTypes(parentCls, result);
+				}
+			}
+		}
+	}
+
+	@Nullable
+	private ClspClass getClspClass(ArgType clsType) {
+		ClspClass clspClass = nameMap.get(clsType.getObject());
+		if (clspClass == null) {
+			missingClasses.add(clsType.getObject());
+		}
+		return clspClass;
+	}
+
+	public void printMissingClasses() {
+		int count = missingClasses.size();
+		if (count == 0) {
+			return;
+		}
+		LOG.warn("Found {} references to unknown classes", count);
+		if (LOG.isDebugEnabled()) {
+			List<String> clsNames = new ArrayList<>(missingClasses);
+			Collections.sort(clsNames);
+			for (String cls : clsNames) {
+				LOG.debug("  {}", cls);
+			}
 		}
 	}
 }

jadx-core/src/main/java/jadx/core/clsp/ClspMethod.java

@@ -0,0 +1,131 @@
+package jadx.core.clsp;
+
+import java.util.List;
+import java.util.Objects;
+
+import org.jetbrains.annotations.NotNull;
+
+import jadx.api.plugins.input.data.AccessFlags;
+import jadx.core.dex.info.MethodInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.IMethodDetails;
+import jadx.core.utils.Utils;
+
+/**
+ * Method node in classpath graph.
+ */
+public class ClspMethod implements IMethodDetails, Comparable<ClspMethod> {
+
+	private final MethodInfo methodInfo;
+	private final List<ArgType> argTypes;
+	private final ArgType returnType;
+	private final List<ArgType> typeParameters;
+	private final List<ArgType> throwList;
+	private final int accFlags;
+
+	public ClspMethod(MethodInfo methodInfo,
+			List<ArgType> argTypes, ArgType returnType,
+			List<ArgType> typeParameters, List<ArgType> throwList, int accFlags) {
+		this.methodInfo = methodInfo;
+		this.argTypes = argTypes;
+		this.returnType = returnType;
+		this.typeParameters = typeParameters;
+		this.throwList = throwList;
+		this.accFlags = accFlags;
+	}
+
+	@Override
+	public MethodInfo getMethodInfo() {
+		return methodInfo;
+	}
+
+	@Override
+	public ArgType getReturnType() {
+		return returnType;
+	}
+
+	@Override
+	public List<ArgType> getArgTypes() {
+		return argTypes;
+	}
+
+	public boolean containsGenericArgs() {
+		return !Objects.equals(argTypes, methodInfo.getArgumentsTypes());
+	}
+
+	public int getArgsCount() {
+		return argTypes.size();
+	}
+
+	@Override
+	public List<ArgType> getTypeParameters() {
+		return typeParameters;
+	}
+
+	@Override
+	public List<ArgType> getThrows() {
+		return throwList;
+	}
+
+	@Override
+	public boolean isVarArg() {
+		return (accFlags & AccessFlags.VARARGS) != 0;
+	}
+
+	@Override
+	public int getRawAccessFlags() {
+		return accFlags;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof ClspMethod)) {
+			return false;
+		}
+		ClspMethod other = (ClspMethod) o;
+		return methodInfo.equals(other.methodInfo);
+	}
+
+	@Override
+	public int hashCode() {
+		return methodInfo.hashCode();
+	}
+
+	@Override
+	public int compareTo(@NotNull ClspMethod other) {
+		return this.methodInfo.compareTo(other.methodInfo);
+	}
+
+	@Override
+	public String toAttrString() {
+		return IMethodDetails.super.toAttrString() + " (c)";
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		sb.append("ClspMth{");
+		if (Utils.notEmpty(getTypeParameters())) {
+			sb.append('<');
+			sb.append(Utils.listToString(getTypeParameters()));
+			sb.append("> ");
+		}
+		sb.append(getMethodInfo().getFullName());
+		sb.append('(');
+		sb.append(Utils.listToString(getArgTypes()));
+		sb.append("):");
+		sb.append(getReturnType());
+		if (isVarArg()) {
+			sb.append(" VARARG");
+		}
+		List<ArgType> throwsList = getThrows();
+		if (Utils.notEmpty(throwsList)) {
+			sb.append(" throws ").append(Utils.listToString(throwsList));
+		}
+		sb.append('}');
+		return sb.toString();
+	}
+}

jadx-core/src/main/java/jadx/core/clsp/ConvertToClsSet.java

@@ -1,67 +0,0 @@
-package jadx.core.clsp;
-
-import jadx.core.dex.nodes.RootNode;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.files.InputFile;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Utility class for convert dex or jar to jadx classes set (.jcst)
- */
-public class ConvertToClsSet {
-	private static final Logger LOG = LoggerFactory.getLogger(ConvertToClsSet.class);
-
-	public static void usage() {
-		LOG.info("<output .jcst or .jar file> <several input dex or jar files> ");
-	}
-
-	public static void main(String[] args) throws IOException, DecodeException {
-		if (args.length < 2) {
-			usage();
-			System.exit(1);
-		}
-		File output = new File(args[0]);
-
-		List<InputFile> inputFiles = new ArrayList<InputFile>(args.length - 1);
-		for (int i = 1; i < args.length; i++) {
-			File f = new File(args[i]);
-			if (f.isDirectory()) {
-				addFilesFromDirectory(f, inputFiles);
-			} else {
-				inputFiles.add(new InputFile(f));
-			}
-		}
-		for (InputFile inputFile : inputFiles) {
-			LOG.info("Loaded: " + inputFile.getFile());
-		}
-
-		RootNode root = new RootNode();
-		root.load(inputFiles);
-
-		ClsSet set = new ClsSet();
-		set.load(root);
-		set.save(output);
-		LOG.info("Output: " + output);
-		LOG.info("done");
-	}
-
-	private static void addFilesFromDirectory(File dir, List<InputFile> inputFiles) throws IOException, DecodeException {
-		File[] files = dir.listFiles();
-		for (File file : files) {
-			if (file.isDirectory()) {
-				addFilesFromDirectory(file, inputFiles);
-			}
-			if (file.getName().endsWith(".dex")) {
-				inputFiles.add(new InputFile(file));
-			}
-		}
-	}
-
-}

jadx-core/src/main/java/jadx/core/clsp/NClass.java

@@ -1,55 +0,0 @@
-package jadx.core.clsp;
-
-/**
- * Class node in classpath graph
- */
-public class NClass {
-
-	private final String name;
-	private NClass[] parents;
-	private int id;
-
-	public NClass(String name, int id) {
-		this.name = name;
-		this.id = id;
-	}
-
-	public String getName() {
-		return name;
-	}
-
-	public int getId() {
-		return id;
-	}
-
-	public void setId(int id) {
-		this.id = id;
-	}
-
-	public NClass[] getParents() {
-		return parents;
-	}
-
-	public void setParents(NClass[] parents) {
-		this.parents = parents;
-	}
-
-	@Override
-	public int hashCode() {
-		return name.hashCode();
-	}
-
-	@Override
-	public boolean equals(Object o) {
-		if (this == o) return true;
-		if (o == null || getClass() != o.getClass()) return false;
-		NClass nClass = (NClass) o;
-		if (!name.equals(nClass.name)) return false;
-		return true;
-	}
-
-	@Override
-	public String toString() {
-		return name;
-	}
-}

jadx-core/src/main/java/jadx/core/clsp/SimpleMethodDetails.java

@@ -0,0 +1,67 @@
+package jadx.core.clsp;
+
+import java.util.Collections;
+import java.util.List;
+
+import jadx.api.plugins.input.data.AccessFlags;
+import jadx.core.dex.info.MethodInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.IMethodDetails;
+
+/**
+ * Method details build from MethodInfo.
+ * Note: some fields have unknown values.
+ */
+public class SimpleMethodDetails implements IMethodDetails {
+
+	private final MethodInfo methodInfo;
+
+	public SimpleMethodDetails(MethodInfo methodInfo) {
+		this.methodInfo = methodInfo;
+	}
+
+	@Override
+	public MethodInfo getMethodInfo() {
+		return methodInfo;
+	}
+
+	@Override
+	public ArgType getReturnType() {
+		return methodInfo.getReturnType();
+	}
+
+	@Override
+	public List<ArgType> getArgTypes() {
+		return methodInfo.getArgumentsTypes();
+	}
+
+	@Override
+	public List<ArgType> getTypeParameters() {
+		return Collections.emptyList();
+	}
+
+	@Override
+	public List<ArgType> getThrows() {
+		return Collections.emptyList();
+	}
+
+	@Override
+	public boolean isVarArg() {
+		return false;
+	}
+
+	@Override
+	public int getRawAccessFlags() {
+		return AccessFlags.PUBLIC;
+	}
+
+	@Override
+	public String toAttrString() {
+		return IMethodDetails.super.toAttrString() + " (s)";
+	}
+
+	@Override
+	public String toString() {
+		return "SimpleMethodDetails{" + methodInfo + '}';
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/AnnotationGen.java

@@ -1,24 +1,31 @@
 package jadx.core.codegen;
 
-import jadx.core.Consts;
-import jadx.core.dex.attributes.AttributeType;
-import jadx.core.dex.attributes.IAttributeNode;
-import jadx.core.dex.attributes.annotations.Annotation;
-import jadx.core.dex.attributes.annotations.AnnotationsList;
-import jadx.core.dex.attributes.annotations.MethodParameters;
-import jadx.core.dex.info.FieldInfo;
-import jadx.core.dex.instructions.args.ArgType;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.FieldNode;
-import jadx.core.dex.nodes.MethodNode;
-import jadx.core.utils.StringUtils;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeWriter;
+import jadx.api.plugins.input.data.IFieldRef;
+import jadx.api.plugins.input.data.annotations.EncodedValue;
+import jadx.api.plugins.input.data.annotations.IAnnotation;
+import jadx.api.plugins.input.data.attributes.JadxAttrType;
+import jadx.api.plugins.input.data.attributes.types.AnnotationDefaultAttr;
+import jadx.api.plugins.input.data.attributes.types.AnnotationsAttr;
+import jadx.api.plugins.input.data.attributes.types.MethodParamsAttr;
+import jadx.core.Consts;
+import jadx.core.dex.attributes.IAttributeNode;
+import jadx.core.dex.info.FieldInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.StringUtils;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
 public class AnnotationGen {
 
 	private final ClassNode cls;
@@ -29,156 +36,189 @@ public class AnnotationGen {
 		this.classGen = classGen;
 	}
 
-	public void addForClass(CodeWriter code) {
+	public void addForClass(ICodeWriter code) {
 		add(cls, code);
 	}
 
-	public void addForMethod(CodeWriter code, MethodNode mth) {
+	public void addForMethod(ICodeWriter code, MethodNode mth) {
 		add(mth, code);
 	}
 
-	public void addForField(CodeWriter code, FieldNode field) {
+	public void addForField(ICodeWriter code, FieldNode field) {
 		add(field, code);
 	}
 
-	public void addForParameter(CodeWriter code, MethodParameters paramsAnnotations, int n) {
-		AnnotationsList aList = paramsAnnotations.getParamList().get(n);
-		if (aList == null || aList.size() == 0)
+	public void addForParameter(ICodeWriter code, MethodParamsAttr paramsAnnotations, int n) {
+		List<AnnotationsAttr> paramList = paramsAnnotations.getParamList();
+		if (n >= paramList.size()) {
 			return;
-
-		for (Annotation a : aList.getAll()) {
-			code.add(formatAnnotation(a));
+		}
+		AnnotationsAttr aList = paramList.get(n);
+		if (aList == null || aList.isEmpty()) {
+			return;
+		}
+		for (IAnnotation a : aList.getAll()) {
+			formatAnnotation(code, a);
 			code.add(' ');
 		}
 	}
 
-	private void add(IAttributeNode node, CodeWriter code) {
-		AnnotationsList aList = (AnnotationsList) node.getAttributes().get(AttributeType.ANNOTATION_LIST);
-		if (aList == null || aList.size() == 0)
+	private void add(IAttributeNode node, ICodeWriter code) {
+		AnnotationsAttr aList = node.get(JadxAttrType.ANNOTATION_LIST);
+		if (aList == null || aList.isEmpty()) {
 			return;
-
-		for (Annotation a : aList.getAll()) {
+		}
+		for (IAnnotation a : aList.getAll()) {
 			String aCls = a.getAnnotationClass();
-			if (aCls.startsWith(Consts.DALVIK_ANNOTATION_PKG)) {
-				// skip
-				if (Consts.DEBUG) {
-					code.startLine("// " + a);
-				}
-			} else {
+			if (!aCls.equals(Consts.OVERRIDE_ANNOTATION)) {
 				code.startLine();
-				code.add(formatAnnotation(a));
+				formatAnnotation(code, a);
 			}
 		}
 	}
 
-	private CodeWriter formatAnnotation(Annotation a) {
-		CodeWriter code = new CodeWriter();
+	private void formatAnnotation(ICodeWriter code, IAnnotation a) {
 		code.add('@');
-		code.add(classGen.useClass(a.getType()));
-		Map<String, Object> vl = a.getValues();
-		if (vl.size() != 0) {
+		ClassNode annCls = cls.root().resolveClass(a.getAnnotationClass());
+		if (annCls != null) {
+			classGen.useClass(code, annCls);
+		} else {
+			classGen.useClass(code, a.getAnnotationClass());
+		}
+
+		Map<String, EncodedValue> vl = a.getValues();
+		if (!vl.isEmpty()) {
 			code.add('(');
-			if (vl.size() == 1 && vl.containsKey("value")) {
-				code.add(encValueToString(vl.get("value")));
-			} else {
-				for (Iterator<Entry<String, Object>> it = vl.entrySet().iterator(); it.hasNext(); ) {
-					Entry<String, Object> e = it.next();
-					code.add(e.getKey());
+			for (Iterator<Entry<String, EncodedValue>> it = vl.entrySet().iterator(); it.hasNext();) {
+				Entry<String, EncodedValue> e = it.next();
+				String paramName = getParamName(annCls, e.getKey());
+				if (paramName.equals("value") && vl.size() == 1) {
+					// don't add "value = " if no other parameters
+				} else {
+					code.add(paramName);
 					code.add(" = ");
-					code.add(encValueToString(e.getValue()));
-					if (it.hasNext())
-						code.add(", ");
+				}
+				encodeValue(cls.root(), code, e.getValue());
+				if (it.hasNext()) {
+					code.add(", ");
 				}
 			}
 			code.add(')');
 		}
-		return code;
 	}
 
-	@SuppressWarnings("unchecked")
-	public void addThrows(MethodNode mth, CodeWriter code) {
-		Annotation an = mth.getAttributes().getAnnotation(Consts.DALVIK_THROWS);
-		if (an != null) {
-			Object exs = an.getDefaultValue();
+	private String getParamName(@Nullable ClassNode annCls, String paramName) {
+		if (annCls != null) {
+			// TODO: save value type and search using signature
+			MethodNode mth = annCls.searchMethodByShortName(paramName);
+			if (mth != null) {
+				return mth.getAlias();
+			}
+		}
+		return paramName;
+	}
+
+	public void addThrows(MethodNode mth, ICodeWriter code) {
+		List<ArgType> throwList = mth.getThrows();
+		if (!throwList.isEmpty()) {
 			code.add(" throws ");
-			for (Iterator<ArgType> it = ((List<ArgType>) exs).iterator(); it.hasNext(); ) {
+			for (Iterator<ArgType> it = throwList.iterator(); it.hasNext();) {
 				ArgType ex = it.next();
-				code.add(TypeGen.translate(classGen, ex));
-				if (it.hasNext())
+				classGen.useType(code, ex);
+				if (it.hasNext()) {
 					code.add(", ");
+				}
 			}
 		}
 	}
 
-	public Object getAnnotationDefaultValue(String name) {
-		Annotation an = cls.getAttributes().getAnnotation(Consts.DALVIK_ANNOTATION_DEFAULT);
-		if (an != null) {
-			Annotation defAnnotation = (Annotation) an.getDefaultValue();
-			return defAnnotation.getValues().get(name);
+	public EncodedValue getAnnotationDefaultValue(MethodNode mth) {
+		AnnotationDefaultAttr defaultAttr = mth.get(JadxAttrType.ANNOTATION_DEFAULT);
+		if (defaultAttr == null) {
+			return null;
 		}
-		return null;
+		return defaultAttr.getValue();
 	}
 
 	// TODO: refactor this boilerplate code
-	@SuppressWarnings("unchecked")
-	public String encValueToString(Object val) {
-		if (val == null)
-			return "null";
-
-		if (val instanceof String)
-			return StringUtils.unescapeString((String) val);
-		if (val instanceof Integer)
-			return TypeGen.formatInteger((Integer) val);
-		if (val instanceof Character)
-			return StringUtils.unescapeChar((Character) val);
-		if (val instanceof Boolean)
-			return Boolean.TRUE.equals(val) ? "true" : "false";
-		if (val instanceof Float)
-			return TypeGen.formatFloat((Float) val);
-		if (val instanceof Double)
-			return TypeGen.formatDouble((Double) val);
-		if (val instanceof Long)
-			return TypeGen.formatLong((Long) val);
-		if (val instanceof Short)
-			return TypeGen.formatShort((Short) val);
-		if (val instanceof Byte)
-			return TypeGen.formatByte((Byte) val);
-
-		if (val instanceof ArgType)
-			return TypeGen.translate(classGen, (ArgType) val) + ".class";
-
-		if (val instanceof FieldInfo) {
-			// must be a static field
-			FieldInfo field = (FieldInfo) val;
-			// FIXME: !!code from InsnGen.sfield
-			String thisClass = cls.getFullName();
-			if (field.getDeclClass().getFullName().equals(thisClass)) {
-				return field.getName();
-			} else {
-				return classGen.useClass(field.getDeclClass()) + '.' + field.getName();
-			}
+	public void encodeValue(RootNode root, ICodeWriter code, EncodedValue encodedValue) {
+		if (encodedValue == null) {
+			code.add("null");
+			return;
 		}
+		Object value = encodedValue.getValue();
+		switch (encodedValue.getType()) {
+			case ENCODED_NULL:
+				code.add("null");
+				break;
+			case ENCODED_BOOLEAN:
+				code.add(Boolean.TRUE.equals(value) ? "true" : "false");
+				break;
+			case ENCODED_BYTE:
+				code.add(TypeGen.formatByte((Byte) value, false));
+				break;
+			case ENCODED_SHORT:
+				code.add(TypeGen.formatShort((Short) value, false));
+				break;
+			case ENCODED_CHAR:
+				code.add(getStringUtils().unescapeChar((Character) value));
+				break;
+			case ENCODED_INT:
+				code.add(TypeGen.formatInteger((Integer) value, false));
+				break;
+			case ENCODED_LONG:
+				code.add(TypeGen.formatLong((Long) value, false));
+				break;
+			case ENCODED_FLOAT:
+				code.add(TypeGen.formatFloat((Float) value));
+				break;
+			case ENCODED_DOUBLE:
+				code.add(TypeGen.formatDouble((Double) value));
+				break;
+			case ENCODED_STRING:
+				code.add(getStringUtils().unescapeString((String) value));
+				break;
+			case ENCODED_TYPE:
+				classGen.useType(code, ArgType.parse((String) value));
+				code.add(".class");
+				break;
+			case ENCODED_ENUM:
+			case ENCODED_FIELD:
+				// must be a static field
+				if (value instanceof IFieldRef) {
+					FieldInfo fieldInfo = FieldInfo.fromRef(root, (IFieldRef) value);
+					InsnGen.makeStaticFieldAccess(code, fieldInfo, classGen);
+				} else if (value instanceof FieldInfo) {
+					InsnGen.makeStaticFieldAccess(code, (FieldInfo) value, classGen);
+				} else {
+					throw new JadxRuntimeException("Unexpected field type class: " + value.getClass());
+				}
+				break;
+			case ENCODED_METHOD:
+				// TODO
+				break;
+			case ENCODED_ARRAY:
+				code.add('{');
+				Iterator<?> it = ((Iterable<?>) value).iterator();
+				while (it.hasNext()) {
+					EncodedValue v = (EncodedValue) it.next();
+					encodeValue(cls.root(), code, v);
+					if (it.hasNext()) {
+						code.add(", ");
+					}
+				}
+				code.add('}');
+				break;
+			case ENCODED_ANNOTATION:
+				formatAnnotation(code, (IAnnotation) value);
+				break;
 
-		if (val instanceof List) {
-			StringBuilder str = new StringBuilder();
-			str.append('{');
-			List<Object> list = (List<Object>) val;
-			for (Iterator<Object> it = list.iterator(); it.hasNext(); ) {
-				Object obj = it.next();
-				str.append(encValueToString(obj));
-				if (it.hasNext())
-					str.append(", ");
-			}
-			str.append('}');
-			return str.toString();
+			default:
+				throw new JadxRuntimeException("Can't decode value: " + encodedValue.getType() + " (" + encodedValue + ')');
 		}
+	}
 
-		if (val instanceof Annotation) {
-			return formatAnnotation((Annotation) val).toString();
-		}
-
-		// TODO: also can be method values
-
-		throw new JadxRuntimeException("Can't decode value: " + val + " (" + val.getClass() + ")");
+	private StringUtils getStringUtils() {
+		return cls.root().getStringUtils();
 	}
 }

jadx-core/src/main/java/jadx/core/codegen/CodeGen.java

@@ -1,29 +1,62 @@
 package jadx.core.codegen;
 
-import jadx.api.IJadxArgs;
+import java.util.concurrent.Callable;
+
+import jadx.api.ICodeInfo;
+import jadx.api.JadxArgs;
+import jadx.api.impl.SimpleCodeInfo;
+import jadx.core.codegen.json.JsonCodeGen;
+import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.visitors.AbstractVisitor;
-import jadx.core.utils.exceptions.CodegenException;
+import jadx.core.utils.exceptions.JadxRuntimeException;
 
-public class CodeGen extends AbstractVisitor {
+public class CodeGen {
 
-	private final IJadxArgs args;
+	public static ICodeInfo generate(ClassNode cls) {
+		if (cls.contains(AFlag.DONT_GENERATE)) {
+			return ICodeInfo.EMPTY;
+		}
+		JadxArgs args = cls.root().getArgs();
+		switch (args.getOutputFormat()) {
+			case JAVA:
+				return generateJavaCode(cls, args);
 
-	public CodeGen(IJadxArgs args) {
-		this.args = args;
+			case JSON:
+				return generateJson(cls);
+
+			default:
+				throw new JadxRuntimeException("Unknown output format");
+		}
 	}
 
-	@Override
-	public boolean visit(ClassNode cls) throws CodegenException {
-		ClassGen clsGen = new ClassGen(cls, null, isFallbackMode());
-		CodeWriter clsCode = clsGen.makeClass();
-		clsCode.finish();
-		cls.setCode(clsCode);
-		return false;
+	private static ICodeInfo generateJavaCode(ClassNode cls, JadxArgs args) {
+		ClassGen clsGen = new ClassGen(cls, args);
+		return wrapCodeGen(cls, clsGen::makeClass);
 	}
 
-	public boolean isFallbackMode() {
-		return args.isFallbackMode();
+	private static ICodeInfo generateJson(ClassNode cls) {
+		JsonCodeGen codeGen = new JsonCodeGen(cls);
+		String clsJson = wrapCodeGen(cls, codeGen::process);
+		return new SimpleCodeInfo(clsJson);
 	}
 
+	private static <R> R wrapCodeGen(ClassNode cls, Callable<R> codeGenFunc) {
+		try {
+			return codeGenFunc.call();
+		} catch (Exception e) {
+			if (cls.contains(AFlag.RESTART_CODEGEN)) {
+				cls.remove(AFlag.RESTART_CODEGEN);
+				try {
+					return codeGenFunc.call();
+				} catch (Exception ex) {
+					throw new JadxRuntimeException("Code generation error after restart", ex);
+				}
+			} else {
+				throw new JadxRuntimeException("Code generation error", e);
+			}
+		}
+	}
+
+	private CodeGen() {
+	}
 }

jadx-core/src/main/java/jadx/core/codegen/CodeWriter.java

@@ -1,230 +0,0 @@
-package jadx.core.codegen;
-
-import jadx.core.dex.attributes.LineAttrNode;
-import jadx.core.utils.Utils;
-
-import java.io.File;
-import java.io.PrintWriter;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class CodeWriter {
-	private static final Logger LOG = LoggerFactory.getLogger(CodeWriter.class);
-	private static final int MAX_FILENAME_LENGTH = 128;
-
-	public static final String NL = System.getProperty("line.separator");
-	private static final String INDENT = "\t";
-
-	private final StringBuilder buf = new StringBuilder();
-	private String indentStr;
-	private int indent;
-
-	private int line = 1;
-	private Map<Object, Integer> annotations = Collections.emptyMap();
-
-	public CodeWriter() {
-		this.indent = 0;
-		this.indentStr = "";
-	}
-
-	public CodeWriter(int indent) {
-		this.indent = indent;
-		updateIndent();
-	}
-
-	public CodeWriter startLine() {
-		addLine();
-		buf.append(indentStr);
-		return this;
-	}
-
-	public CodeWriter startLine(char c) {
-		addLine();
-		buf.append(indentStr);
-		buf.append(c);
-		return this;
-	}
-
-	public CodeWriter startLine(String str) {
-		addLine();
-		buf.append(indentStr);
-		buf.append(str);
-		return this;
-	}
-
-	public CodeWriter startLine(int ind, String str) {
-		addLine();
-		buf.append(indentStr);
-		for (int i = 0; i < ind; i++)
-			buf.append(INDENT);
-		buf.append(str);
-		return this;
-	}
-
-	public CodeWriter add(String str) {
-		buf.append(str);
-		return this;
-	}
-
-	public CodeWriter add(char c) {
-		buf.append(c);
-		return this;
-	}
-
-	public CodeWriter add(CodeWriter code) {
-		line--;
-		for (Map.Entry<Object, Integer> entry : code.annotations.entrySet()) {
-			attachAnnotation(entry.getKey(), line + entry.getValue());
-		}
-		line += code.line;
-		buf.append(code.toString());
-		return this;
-	}
-
-	public CodeWriter newLine() {
-		addLine();
-		return this;
-	}
-
-	private void addLine() {
-		buf.append(NL);
-		line++;
-	}
-
-	public int getLine() {
-		return line;
-	}
-
-	public Object attachAnnotation(Object obj) {
-		return attachAnnotation(obj, line);
-	}
-
-	public Object attachAnnotation(Object obj, int line) {
-		if (annotations.isEmpty()) {
-			annotations = new HashMap<Object, Integer>();
-		}
-		return annotations.put(obj, line);
-	}
-
-	public CodeWriter indent() {
-		buf.append(indentStr);
-		return this;
-	}
-
-	private static final String[] INDENT_CACHE = new String[]{
-			"",
-			INDENT,
-			INDENT + INDENT,
-			INDENT + INDENT + INDENT,
-			INDENT + INDENT + INDENT + INDENT,
-			INDENT + INDENT + INDENT + INDENT + INDENT,
-	};
-
-	private void updateIndent() {
-		int curIndent = indent;
-		if (curIndent < 6) {
-			this.indentStr = INDENT_CACHE[curIndent];
-		} else {
-			StringBuilder s = new StringBuilder(curIndent * INDENT.length());
-			for (int i = 0; i < curIndent; i++) {
-				s.append(INDENT);
-			}
-			this.indentStr = s.toString();
-		}
-	}
-
-	public int getIndent() {
-		return indent;
-	}
-
-	public void incIndent() {
-		incIndent(1);
-	}
-
-	public void decIndent() {
-		decIndent(1);
-	}
-
-	public void incIndent(int c) {
-		this.indent += c;
-		updateIndent();
-	}
-
-	public void decIndent(int c) {
-		this.indent -= c;
-		if (this.indent < 0) {
-			LOG.warn("Indent < 0");
-			this.indent = 0;
-		}
-		updateIndent();
-	}
-
-	public void finish() {
-		buf.trimToSize();
-		for (Map.Entry<Object, Integer> entry : annotations.entrySet()) {
-			Object v = entry.getKey();
-			if (v instanceof LineAttrNode) {
-				LineAttrNode l = (LineAttrNode) v;
-				l.setDecompiledLine(entry.getValue());
-			}
-		}
-		annotations.clear();
-	}
-
-	private static String removeFirstEmptyLine(String str) {
-		if (str.startsWith(NL)) {
-			return str.substring(NL.length());
-		} else {
-			return str;
-		}
-	}
-
-	public boolean notEmpty() {
-		return buf.length() != 0;
-	}
-
-	@Override
-	public String toString() {
-		return buf.toString();
-	}
-
-	public void save(File dir, String subDir, String fileName) {
-		save(dir, new File(subDir, fileName).getPath());
-	}
-
-	public void save(File dir, String fileName) {
-		save(new File(dir, fileName));
-	}
-
-	public void save(File file) {
-		String name = file.getName();
-		if (name.length() > MAX_FILENAME_LENGTH) {
-			int dotIndex = name.indexOf('.');
-			int cutAt = MAX_FILENAME_LENGTH - name.length() + dotIndex - 1;
-			if (cutAt <= 0)
-				name = name.substring(0, MAX_FILENAME_LENGTH - 1);
-			else
-				name = name.substring(0, cutAt) + name.substring(dotIndex);
-			file = new File(file.getParentFile(), name);
-		}
-
-		PrintWriter out = null;
-		try {
-			Utils.makeDirsForFile(file);
-			out = new PrintWriter(file, "UTF-8");
-			String code = buf.toString();
-			code = removeFirstEmptyLine(code);
-			out.print(code);
-		} catch (Exception e) {
-			LOG.error("Save file error", e);
-		} finally {
-			if (out != null)
-				out.close();
-		}
-	}
-
-}

jadx-core/src/main/java/jadx/core/codegen/ConditionGen.java

@@ -0,0 +1,198 @@
+package jadx.core.codegen;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+
+import jadx.api.ICodeWriter;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.instructions.ArithNode;
+import jadx.core.dex.instructions.IfOp;
+import jadx.core.dex.instructions.InsnType;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.instructions.args.InsnArg;
+import jadx.core.dex.instructions.args.InsnWrapArg;
+import jadx.core.dex.instructions.args.LiteralArg;
+import jadx.core.dex.nodes.InsnNode;
+import jadx.core.dex.regions.conditions.Compare;
+import jadx.core.dex.regions.conditions.IfCondition;
+import jadx.core.dex.regions.conditions.IfCondition.Mode;
+import jadx.core.utils.exceptions.CodegenException;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
+public class ConditionGen extends InsnGen {
+
+	private static class CondStack {
+		private final Queue<IfCondition> stack = new LinkedList<>();
+
+		public Queue<IfCondition> getStack() {
+			return stack;
+		}
+
+		public void push(IfCondition cond) {
+			stack.add(cond);
+		}
+
+		public IfCondition pop() {
+			return stack.poll();
+		}
+	}
+
+	public ConditionGen(InsnGen insnGen) {
+		super(insnGen.mgen, insnGen.fallback);
+	}
+
+	void add(ICodeWriter code, IfCondition condition) throws CodegenException {
+		add(code, new CondStack(), condition);
+	}
+
+	void wrap(ICodeWriter code, IfCondition condition) throws CodegenException {
+		wrap(code, new CondStack(), condition);
+	}
+
+	private void add(ICodeWriter code, CondStack stack, IfCondition condition) throws CodegenException {
+		stack.push(condition);
+		switch (condition.getMode()) {
+			case COMPARE:
+				addCompare(code, stack, condition.getCompare());
+				break;
+
+			case TERNARY:
+				addTernary(code, stack, condition);
+				break;
+
+			case NOT:
+				addNot(code, stack, condition);
+				break;
+
+			case AND:
+			case OR:
+				addAndOr(code, stack, condition);
+				break;
+
+			default:
+				throw new JadxRuntimeException("Unknown condition mode: " + condition.getMode());
+		}
+		stack.pop();
+	}
+
+	private void wrap(ICodeWriter code, CondStack stack, IfCondition cond) throws CodegenException {
+		boolean wrap = isWrapNeeded(cond);
+		if (wrap) {
+			code.add('(');
+		}
+		add(code, stack, cond);
+		if (wrap) {
+			code.add(')');
+		}
+	}
+
+	private void wrap(ICodeWriter code, InsnArg firstArg) throws CodegenException {
+		boolean wrap = isArgWrapNeeded(firstArg);
+		if (wrap) {
+			code.add('(');
+		}
+		addArg(code, firstArg, false);
+		if (wrap) {
+			code.add(')');
+		}
+	}
+
+	private void addCompare(ICodeWriter code, CondStack stack, Compare compare) throws CodegenException {
+		IfOp op = compare.getOp();
+		InsnArg firstArg = compare.getA();
+		InsnArg secondArg = compare.getB();
+		if (firstArg.getType().equals(ArgType.BOOLEAN)
+				&& secondArg.isLiteral()
+				&& secondArg.getType().equals(ArgType.BOOLEAN)) {
+			LiteralArg lit = (LiteralArg) secondArg;
+			if (lit.getLiteral() == 0) {
+				op = op.invert();
+			}
+			if (op == IfOp.EQ) {
+				// == true
+				if (stack.getStack().size() == 1) {
+					addArg(code, firstArg, false);
+				} else {
+					wrap(code, firstArg);
+				}
+				return;
+			} else if (op == IfOp.NE) {
+				// != true
+				code.add('!');
+				wrap(code, firstArg);
+				return;
+			}
+			mth.addWarn("Unsupported boolean condition " + op.getSymbol());
+		}
+
+		addArg(code, firstArg, isArgWrapNeeded(firstArg));
+		code.add(' ').add(op.getSymbol()).add(' ');
+		addArg(code, secondArg, isArgWrapNeeded(secondArg));
+	}
+
+	private void addTernary(ICodeWriter code, CondStack stack, IfCondition condition) throws CodegenException {
+		add(code, stack, condition.first());
+		code.add(" ? ");
+		add(code, stack, condition.second());
+		code.add(" : ");
+		add(code, stack, condition.third());
+	}
+
+	private void addNot(ICodeWriter code, CondStack stack, IfCondition condition) throws CodegenException {
+		code.add('!');
+		wrap(code, stack, condition.getArgs().get(0));
+	}
+
+	private void addAndOr(ICodeWriter code, CondStack stack, IfCondition condition) throws CodegenException {
+		String mode = condition.getMode() == Mode.AND ? " && " : " || ";
+		Iterator<IfCondition> it = condition.getArgs().iterator();
+		while (it.hasNext()) {
+			wrap(code, stack, it.next());
+			if (it.hasNext()) {
+				code.add(mode);
+			}
+		}
+	}
+
+	private boolean isWrapNeeded(IfCondition condition) {
+		if (condition.isCompare() || condition.contains(AFlag.DONT_WRAP)) {
+			return false;
+		}
+		return condition.getMode() != Mode.NOT;
+	}
+
+	private static boolean isArgWrapNeeded(InsnArg arg) {
+		if (!arg.isInsnWrap()) {
+			return false;
+		}
+		InsnNode insn = ((InsnWrapArg) arg).getWrapInsn();
+		InsnType insnType = insn.getType();
+		if (insnType == InsnType.ARITH) {
+			switch (((ArithNode) insn).getOp()) {
+				case ADD:
+				case SUB:
+				case MUL:
+				case DIV:
+				case REM:
+					return false;
+
+				default:
+					return true;
+			}
+		} else {
+			switch (insnType) {
+				case INVOKE:
+				case SGET:
+				case IGET:
+				case AGET:
+				case CONST:
+				case ARRAY_LENGTH:
+					return false;
+
+				default:
+					return true;
+			}
+		}
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/MethodGen.java

@@ -1,322 +1,436 @@
 package jadx.core.codegen;
 
-import jadx.core.Consts;
-import jadx.core.dex.attributes.AttributeFlag;
-import jadx.core.dex.attributes.AttributeType;
-import jadx.core.dex.attributes.AttributesList;
-import jadx.core.dex.attributes.JadxErrorAttr;
-import jadx.core.dex.attributes.annotations.MethodParameters;
-import jadx.core.dex.info.AccessInfo;
-import jadx.core.dex.instructions.args.ArgType;
-import jadx.core.dex.instructions.args.NamedArg;
-import jadx.core.dex.instructions.args.RegisterArg;
-import jadx.core.dex.nodes.InsnNode;
-import jadx.core.dex.nodes.MethodNode;
-import jadx.core.dex.trycatch.CatchAttr;
-import jadx.core.dex.visitors.DepthTraverser;
-import jadx.core.dex.visitors.FallbackModeVisitor;
-import jadx.core.utils.ErrorsCounter;
-import jadx.core.utils.InsnUtils;
-import jadx.core.utils.Utils;
-import jadx.core.utils.exceptions.CodegenException;
-import jadx.core.utils.exceptions.DecodeException;
-
-import java.util.HashSet;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Set;
+import java.util.Objects;
+import java.util.stream.Stream;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.android.dx.rop.code.AccessFlags;
+import jadx.api.CommentsLevel;
+import jadx.api.ICodeWriter;
+import jadx.api.data.annotations.InsnCodeOffset;
+import jadx.api.data.annotations.VarDeclareRef;
+import jadx.api.plugins.input.data.AccessFlags;
+import jadx.api.plugins.input.data.annotations.EncodedValue;
+import jadx.api.plugins.input.data.attributes.JadxAttrType;
+import jadx.api.plugins.input.data.attributes.types.MethodParamsAttr;
+import jadx.core.Consts;
+import jadx.core.Jadx;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.nodes.JadxError;
+import jadx.core.dex.attributes.nodes.JumpInfo;
+import jadx.core.dex.attributes.nodes.MethodOverrideAttr;
+import jadx.core.dex.info.AccessInfo;
+import jadx.core.dex.instructions.ConstStringNode;
+import jadx.core.dex.instructions.IfNode;
+import jadx.core.dex.instructions.InsnType;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.instructions.args.CodeVar;
+import jadx.core.dex.instructions.args.RegisterArg;
+import jadx.core.dex.instructions.args.SSAVar;
+import jadx.core.dex.nodes.InsnNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.trycatch.CatchAttr;
+import jadx.core.dex.visitors.DepthTraversal;
+import jadx.core.dex.visitors.IDexTreeVisitor;
+import jadx.core.utils.CodeGenUtils;
+import jadx.core.utils.InsnUtils;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.CodegenException;
+import jadx.core.utils.exceptions.JadxOverflowException;
+
+import static jadx.core.codegen.MethodGen.FallbackOption.BLOCK_DUMP;
+import static jadx.core.codegen.MethodGen.FallbackOption.COMMENTED_DUMP;
+import static jadx.core.codegen.MethodGen.FallbackOption.FALLBACK_MODE;
 
 public class MethodGen {
 	private static final Logger LOG = LoggerFactory.getLogger(MethodGen.class);
 
 	private final MethodNode mth;
 	private final ClassGen classGen;
-	private final boolean fallback;
 	private final AnnotationGen annotationGen;
-
-	private final Set<String> varNames = new HashSet<String>();
+	private final NameGen nameGen;
 
 	public MethodGen(ClassGen classGen, MethodNode mth) {
 		this.mth = mth;
 		this.classGen = classGen;
-		this.fallback = classGen.isFallbackMode();
 		this.annotationGen = classGen.getAnnotationGen();
-
-		List<RegisterArg> args = mth.getArguments(true);
-		for (RegisterArg arg : args) {
-			varNames.add(makeArgName(arg));
-		}
+		this.nameGen = new NameGen(mth, classGen);
 	}
 
 	public ClassGen getClassGen() {
 		return classGen;
 	}
 
-	public boolean addDefinition(CodeWriter code) {
+	public NameGen getNameGen() {
+		return nameGen;
+	}
+
+	public MethodNode getMethodNode() {
+		return mth;
+	}
+
+	public boolean addDefinition(ICodeWriter code) {
 		if (mth.getMethodInfo().isClassInit()) {
+			code.attachDefinition(mth);
 			code.startLine("static");
-			code.attachAnnotation(mth);
 			return true;
 		}
-		if (mth.getAttributes().contains(AttributeFlag.ANONYMOUS_CONSTRUCTOR)) {
+		if (mth.contains(AFlag.ANONYMOUS_CONSTRUCTOR)) {
 			// don't add method name and arguments
 			code.startLine();
-			code.attachAnnotation(mth);
+			code.attachDefinition(mth);
 			return false;
 		}
+		if (Consts.DEBUG_USAGE) {
+			ClassGen.addMthUsageInfo(code, mth);
+		}
+		addOverrideAnnotation(code, mth);
 		annotationGen.addForMethod(code, mth);
 
 		AccessInfo clsAccFlags = mth.getParentClass().getAccessFlags();
 		AccessInfo ai = mth.getAccessFlags();
-		// don't add 'abstract' to methods in interface
+		// don't add 'abstract' and 'public' to methods in interface
 		if (clsAccFlags.isInterface()) {
-			ai = ai.remove(AccessFlags.ACC_ABSTRACT);
+			ai = ai.remove(AccessFlags.ABSTRACT);
+			ai = ai.remove(AccessFlags.PUBLIC);
 		}
 		// don't add 'public' for annotations
 		if (clsAccFlags.isAnnotation()) {
-			ai = ai.remove(AccessFlags.ACC_PUBLIC);
+			ai = ai.remove(AccessFlags.PUBLIC);
+		}
+		if (mth.getMethodInfo().isConstructor() && mth.getParentClass().isEnum()) {
+			ai = ai.remove(AccessInfo.VISIBILITY_FLAGS);
 		}
-		code.startLine(ai.makeString());
 
-		if (classGen.makeGenericMap(code, mth.getGenericMap())) {
+		if (mth.getMethodInfo().hasAlias() && !ai.isConstructor()) {
+			CodeGenUtils.addRenamedComment(code, mth, mth.getName());
+		}
+		if (mth.contains(AFlag.INCONSISTENT_CODE) && mth.checkCommentsLevel(CommentsLevel.ERROR)) {
+			code.startLine("/* Code decompiled incorrectly, please refer to instructions dump */");
+		}
+
+		code.startLineWithNum(mth.getSourceLine());
+		code.add(ai.makeString(mth.checkCommentsLevel(CommentsLevel.INFO)));
+		if (clsAccFlags.isInterface() && !mth.isNoCode() && !mth.getAccessFlags().isStatic()) {
+			// add 'default' for method with code in interface
+			code.add("default ");
+		}
+
+		if (classGen.addGenericTypeParameters(code, mth.getTypeParameters(), false)) {
 			code.add(' ');
 		}
-		if (mth.getAccessFlags().isConstructor()) {
+		if (ai.isConstructor()) {
+			code.attachDefinition(mth);
 			code.add(classGen.getClassNode().getShortName()); // constructor
 		} else {
-			code.add(TypeGen.translate(classGen, mth.getReturnType()));
+			classGen.useType(code, mth.getReturnType());
 			code.add(' ');
-			code.add(mth.getName());
+			code.attachDefinition(mth);
+			code.add(mth.getAlias());
 		}
 		code.add('(');
 
-		List<RegisterArg> args = mth.getArguments(false);
+		List<RegisterArg> args = mth.getArgRegs();
 		if (mth.getMethodInfo().isConstructor()
-				&& mth.getParentClass().getAttributes().contains(AttributeType.ENUM_CLASS)) {
+				&& mth.getParentClass().contains(AType.ENUM_CLASS)) {
 			if (args.size() == 2) {
-				args.clear();
+				args = Collections.emptyList();
 			} else if (args.size() > 2) {
 				args = args.subList(2, args.size());
 			} else {
-				LOG.warn(ErrorsCounter.formatErrorMsg(mth,
-						"Incorrect number of args for enum constructor: " + args.size()
-								+ " (expected >= 2)"));
+				mth.addWarnComment("Incorrect number of args for enum constructor: " + args.size() + " (expected >= 2)");
 			}
+		} else if (mth.contains(AFlag.SKIP_FIRST_ARG)) {
+			args = args.subList(1, args.size());
 		}
-		code.add(makeArguments(args));
-		code.add(")");
+		addMethodArguments(code, args);
+		code.add(')');
 
 		annotationGen.addThrows(mth, code);
-		code.attachAnnotation(mth);
+
+		// add default value for annotation class
+		if (mth.getParentClass().getAccessFlags().isAnnotation()) {
+			EncodedValue def = annotationGen.getAnnotationDefaultValue(mth);
+			if (def != null) {
+				code.add(" default ");
+				annotationGen.encodeValue(mth.root(), code, def);
+			}
+		}
 		return true;
 	}
 
-	public CodeWriter makeArguments(List<RegisterArg> args) {
-		CodeWriter argsCode = new CodeWriter();
-
-		MethodParameters paramsAnnotation =
-				(MethodParameters) mth.getAttributes().get(AttributeType.ANNOTATION_MTH_PARAMETERS);
+	private void addOverrideAnnotation(ICodeWriter code, MethodNode mth) {
+		MethodOverrideAttr overrideAttr = mth.get(AType.METHOD_OVERRIDE);
+		if (overrideAttr == null) {
+			return;
+		}
+		if (!overrideAttr.isAtBaseMth()) {
+			code.startLine("@Override");
+			if (mth.checkCommentsLevel(CommentsLevel.INFO)) {
+				code.add(" // ");
+				code.add(Utils.listToString(overrideAttr.getOverrideList(), ", ",
+						md -> md.getMethodInfo().getDeclClass().getAliasFullName()));
+			}
+		}
+		if (Consts.DEBUG) {
+			code.startLine("// related by override: ");
+			code.add(Utils.listToString(overrideAttr.getRelatedMthNodes(), ", ", m -> m.getParentClass().getFullName()));
+		}
+	}
 
+	private void addMethodArguments(ICodeWriter code, List<RegisterArg> args) {
+		MethodParamsAttr paramsAnnotation = mth.get(JadxAttrType.ANNOTATION_MTH_PARAMETERS);
 		int i = 0;
-		for (Iterator<RegisterArg> it = args.iterator(); it.hasNext(); ) {
-			RegisterArg arg = it.next();
+		Iterator<RegisterArg> it = args.iterator();
+		while (it.hasNext()) {
+			RegisterArg mthArg = it.next();
+			SSAVar ssaVar = mthArg.getSVar();
+			CodeVar var;
+			if (ssaVar == null) {
+				// abstract or interface methods
+				var = CodeVar.fromMthArg(mthArg, classGen.isFallbackMode());
+			} else {
+				var = ssaVar.getCodeVar();
+			}
 
 			// add argument annotation
-			if (paramsAnnotation != null)
-				annotationGen.addForParameter(argsCode, paramsAnnotation, i);
-
+			if (paramsAnnotation != null) {
+				annotationGen.addForParameter(code, paramsAnnotation, i);
+			}
+			if (var.isFinal()) {
+				code.add("final ");
+			}
+			ArgType argType;
+			ArgType varType = var.getType();
+			if (varType == null || varType == ArgType.UNKNOWN) {
+				// occur on decompilation errors
+				argType = mthArg.getInitType();
+			} else {
+				argType = varType;
+			}
 			if (!it.hasNext() && mth.getAccessFlags().isVarArgs()) {
 				// change last array argument to varargs
-				ArgType type = arg.getType();
-				if (type.isArray()) {
-					ArgType elType = type.getArrayElement();
-					argsCode.add(TypeGen.translate(classGen, elType));
-					argsCode.add(" ...");
+				if (argType.isArray()) {
+					ArgType elType = argType.getArrayElement();
+					classGen.useType(code, elType);
+					code.add("...");
 				} else {
-					LOG.warn(ErrorsCounter.formatErrorMsg(mth, "Last argument in varargs method not array"));
-					argsCode.add(TypeGen.translate(classGen, arg.getType()));
+					mth.addWarnComment("Last argument in varargs method is not array: " + var);
+					classGen.useType(code, argType);
 				}
 			} else {
-				argsCode.add(TypeGen.translate(classGen, arg.getType()));
+				classGen.useType(code, argType);
 			}
-			argsCode.add(' ');
-			argsCode.add(makeArgName(arg));
+			code.add(' ');
+			if (code.isMetadataSupported() && ssaVar != null) {
+				code.attachDefinition(VarDeclareRef.get(mth, var));
+			}
+			code.add(nameGen.assignArg(var));
 
 			i++;
-			if (it.hasNext())
-				argsCode.add(", ");
+			if (it.hasNext()) {
+				code.add(", ");
+			}
 		}
-		return argsCode;
 	}
 
-	/**
-	 * Make variable name for register,
-	 * Name contains register number and
-	 * variable type or name (if debug info available)
-	 */
-	public String makeArgName(RegisterArg arg) {
-		String name = arg.getTypedVar().getName();
-		String base = "r" + arg.getRegNum();
-		if (fallback) {
-			if (name != null)
-				return base + "_" + name;
-			else
-				return base;
+	public void addInstructions(ICodeWriter code) throws CodegenException {
+		if (mth.root().getArgs().isFallbackMode()) {
+			addFallbackMethodCode(code, FALLBACK_MODE);
+		} else if (classGen.isFallbackMode()) {
+			dumpInstructions(code);
 		} else {
-			if (name != null) {
-				if (name.equals("this"))
-					return name;
-				else if (Consts.DEBUG)
-					return name + "_" + base;
-				else
-					return name;
-			} else {
-				ArgType type = arg.getType();
-				if (type.isPrimitive())
-					return base + type.getPrimitiveType().getShortName().toLowerCase();
-				else
-					return base + "_" + Utils.escape(TypeGen.translate(classGen, arg.getType()));
-			}
+			addRegionInsns(code);
 		}
 	}
 
-	/**
-	 * Put variable declaration and return variable name (used for assignments)
-	 *
-	 * @param arg register variable
-	 * @return variable name
-	 */
-	public String assignArg(RegisterArg arg) {
-		String name = makeArgName(arg);
-		if (varNames.add(name) || fallback)
-			return name;
-
-		name = getUniqVarName(name);
-		arg.getTypedVar().setName(name);
-		return name;
-	}
-
-	public String assignNamedArg(NamedArg arg) {
-		String name = arg.getName();
-		if (varNames.add(name) || fallback)
-			return name;
-
-		name = getUniqVarName(name);
-		arg.setName(name);
-		return name;
-	}
-
-	private String getUniqVarName(String name) {
-		String r;
-		int i = 2;
-		do {
-			r = name + "_" + i;
-			i++;
-		} while (varNames.contains(r));
-		varNames.add(r);
-		return r;
-	}
-
-	public CodeWriter makeInstructions(int mthIndent) throws CodegenException {
-		CodeWriter code = new CodeWriter(mthIndent + 1);
-
-		if (mth.getAttributes().contains(AttributeType.JADX_ERROR)) {
-			code.startLine("throw new UnsupportedOperationException(\"Method not decompiled: ");
-			code.add(mth.toString());
-			code.add("\");");
-
-			JadxErrorAttr err = (JadxErrorAttr) mth.getAttributes().get(AttributeType.JADX_ERROR);
-			code.startLine("// jadx: method processing error");
-			Throwable cause = err.getCause();
-			if (cause != null) {
-				code.newLine();
-				code.add("/*");
-				code.startLine("Error: ").add(Utils.getStackTrace(cause));
-				code.add("*/");
-			}
-			makeMethodDump(code);
-		} else {
-			if (mth.getRegion() != null) {
-				CodeWriter insns = new CodeWriter(mthIndent + 1);
-				(new RegionGen(this, mth)).makeRegion(insns, mth.getRegion());
-				code.add(insns);
-			} else {
-				makeFallbackMethod(code, mth);
+	public void addRegionInsns(ICodeWriter code) throws CodegenException {
+		try {
+			RegionGen regionGen = new RegionGen(this);
+			regionGen.makeRegion(code, mth.getRegion());
+		} catch (StackOverflowError | BootstrapMethodError e) {
+			mth.addError("Method code generation error", new JadxOverflowException("StackOverflow"));
+			CodeGenUtils.addErrors(code, mth);
+			dumpInstructions(code);
+		} catch (Exception e) {
+			if (mth.getParentClass().getTopParentClass().contains(AFlag.RESTART_CODEGEN)) {
+				throw e;
 			}
+			mth.addError("Method code generation error", e);
+			CodeGenUtils.addErrors(code, mth);
+			dumpInstructions(code);
 		}
-		return code;
 	}
 
-	public void makeMethodDump(CodeWriter code) {
-		code.startLine("/*");
-		getFallbackMethodGen(mth).addDefinition(code);
-		code.add(" {");
-		code.incIndent();
-
-		makeFallbackMethod(code, mth);
-
-		code.decIndent();
-		code.startLine('}');
-		code.startLine("*/");
+	public void dumpInstructions(ICodeWriter code) {
+		if (mth.checkCommentsLevel(CommentsLevel.ERROR)) {
+			code.startLine("/*");
+			addFallbackMethodCode(code, COMMENTED_DUMP);
+			code.startLine("*/");
+		}
+		code.startLine("throw new UnsupportedOperationException(\"Method not decompiled: ")
+				.add(mth.getParentClass().getClassInfo().getAliasFullName())
+				.add('.')
+				.add(mth.getAlias())
+				.add('(')
+				.add(Utils.listToString(mth.getMethodInfo().getArgumentsTypes()))
+				.add("):")
+				.add(mth.getMethodInfo().getReturnType().toString())
+				.add("\");");
 	}
 
-	private void makeFallbackMethod(CodeWriter code, MethodNode mth) {
-		if (mth.getInstructions() == null) {
-			// loadFile original instructions
+	public void addFallbackMethodCode(ICodeWriter code, FallbackOption fallbackOption) {
+		if (fallbackOption != FALLBACK_MODE) {
+			List<JadxError> errors = mth.getAll(AType.JADX_ERROR); // preserve error before unload
 			try {
+				// load original instructions
+				mth.unload();
 				mth.load();
-				DepthTraverser.visit(new FallbackModeVisitor(), mth);
-			} catch (DecodeException e) {
-				// ignore
-				code.startLine("Can't loadFile method instructions");
+				for (IDexTreeVisitor visitor : Jadx.getFallbackPassesList()) {
+					DepthTraversal.visit(visitor, mth);
+				}
+				errors.forEach(err -> mth.addAttr(AType.JADX_ERROR, err));
+			} catch (Exception e) {
+				LOG.error("Error reload instructions in fallback mode:", e);
+				code.startLine("// Can't load method instructions: " + e.getMessage());
+				return;
+			} finally {
+				errors.forEach(err -> mth.addAttr(AType.JADX_ERROR, err));
+			}
+		}
+		InsnNode[] insnArr = mth.getInstructions();
+		if (insnArr == null) {
+			code.startLine("// Can't load method instructions.");
+			return;
+		}
+		if (fallbackOption == COMMENTED_DUMP && mth.getCommentsLevel() != CommentsLevel.DEBUG) {
+			long insnCountEstimate = Stream.of(insnArr)
+					.filter(Objects::nonNull)
+					.filter(insn -> insn.getType() != InsnType.NOP)
+					.count();
+			if (insnCountEstimate > 100) {
+				code.startLine("// Method dump skipped, instructions count: " + insnArr.length);
 				return;
 			}
 		}
+		code.incIndent();
 		if (mth.getThisArg() != null) {
-			code.startLine(getFallbackMethodGen(mth).makeArgName(mth.getThisArg())).add(" = this;");
+			code.startLine(nameGen.useArg(mth.getThisArg())).add(" = this;");
 		}
-		makeFallbackInsns(code, mth, mth.getInstructions(), true);
+		addFallbackInsns(code, mth, insnArr, fallbackOption);
+		code.decIndent();
 	}
 
-	public static void makeFallbackInsns(CodeWriter code, MethodNode mth, List<InsnNode> insns, boolean addLabels) {
-		InsnGen insnGen = new InsnGen(getFallbackMethodGen(mth), mth, true);
-		for (InsnNode insn : insns) {
-			AttributesList attrs = insn.getAttributes();
-			if (addLabels) {
-				if (attrs.contains(AttributeType.JUMP)
-						|| attrs.contains(AttributeType.EXC_HANDLER)) {
-					code.decIndent();
-					code.startLine(getLabelName(insn.getOffset()) + ":");
-					code.incIndent();
+	public enum FallbackOption {
+		FALLBACK_MODE,
+		BLOCK_DUMP,
+		COMMENTED_DUMP
+	}
+
+	public static void addFallbackInsns(ICodeWriter code, MethodNode mth, InsnNode[] insnArr, FallbackOption option) {
+		int startIndent = code.getIndent();
+		InsnGen insnGen = new InsnGen(getFallbackMethodGen(mth), true);
+		InsnNode prevInsn = null;
+		for (InsnNode insn : insnArr) {
+			if (insn == null) {
+				continue;
+			}
+			if (insn.contains(AType.JADX_ERROR)) {
+				for (JadxError error : insn.getAll(AType.JADX_ERROR)) {
+					code.startLine("// ").add(error.getError());
 				}
+				continue;
+			}
+			if (option != BLOCK_DUMP && needLabel(insn, prevInsn)) {
+				code.decIndent();
+				code.startLine(getLabelName(insn.getOffset()) + ':');
+				code.incIndent();
+			}
+			if (insn.getType() == InsnType.NOP) {
+				continue;
 			}
 			try {
-				if (insnGen.makeInsn(insn, code)) {
-					CatchAttr catchAttr = (CatchAttr) attrs.get(AttributeType.CATCH_BLOCK);
-					if (catchAttr != null)
-						code.add("\t //" + catchAttr);
+				boolean escapeComment = isCommentEscapeNeeded(insn, option);
+				if (escapeComment) {
+					code.decIndent();
+					code.startLine("*/");
+					code.startLine("//  ");
+				} else {
+					code.startLineWithNum(insn.getSourceLine());
 				}
-			} catch (CodegenException e) {
+				InsnCodeOffset.attach(code, insn);
+				RegisterArg resArg = insn.getResult();
+				if (resArg != null) {
+					ArgType varType = resArg.getInitType();
+					if (varType.isTypeKnown()) {
+						code.add(varType.toString()).add(' ');
+					}
+				}
+				insnGen.makeInsn(insn, code, InsnGen.Flags.INLINE);
+				if (escapeComment) {
+					code.startLine("/*");
+					code.incIndent();
+				}
+
+				CatchAttr catchAttr = insn.get(AType.EXC_CATCH);
+				if (catchAttr != null) {
+					code.add("     // " + catchAttr);
+				}
+				CodeGenUtils.addCodeComments(code, mth, insn);
+			} catch (Exception e) {
+				LOG.debug("Error generate fallback instruction: ", e.getCause());
+				code.setIndent(startIndent);
 				code.startLine("// error: " + insn);
 			}
+			prevInsn = insn;
 		}
 	}
 
+	private static boolean isCommentEscapeNeeded(InsnNode insn, FallbackOption option) {
+		if (option == COMMENTED_DUMP) {
+			if (insn.getType() == InsnType.CONST_STR) {
+				String str = ((ConstStringNode) insn).getString();
+				return str.contains("*/");
+			}
+		}
+		return false;
+	}
+
+	private static boolean needLabel(InsnNode insn, InsnNode prevInsn) {
+		if (insn.contains(AType.EXC_HANDLER)) {
+			return true;
+		}
+		if (insn.contains(AType.JUMP)) {
+			// don't add label for ifs else branch
+			if (prevInsn != null && prevInsn.getType() == InsnType.IF) {
+				List<JumpInfo> jumps = insn.getAll(AType.JUMP);
+				if (jumps.size() == 1) {
+					JumpInfo jump = jumps.get(0);
+					if (jump.getSrc() == prevInsn.getOffset() && jump.getDest() == insn.getOffset()) {
+						int target = ((IfNode) prevInsn).getTarget();
+						return insn.getOffset() == target;
+					}
+				}
+			}
+			return true;
+		}
+		return false;
+	}
+
 	/**
 	 * Return fallback variant of method codegen
 	 */
-	private static MethodGen getFallbackMethodGen(MethodNode mth) {
-		ClassGen clsGen = new ClassGen(mth.getParentClass(), null, true);
+	public static MethodGen getFallbackMethodGen(MethodNode mth) {
+		ClassGen clsGen = new ClassGen(mth.getParentClass(), null, false, true, true);
 		return new MethodGen(clsGen, mth);
 	}
 
 	public static String getLabelName(int offset) {
 		return "L_" + InsnUtils.formatOffset(offset);
 	}
-
 }

jadx-core/src/main/java/jadx/core/codegen/NameGen.java

@@ -0,0 +1,286 @@
+package jadx.core.codegen;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import jadx.core.Consts;
+import jadx.core.deobf.NameMapper;
+import jadx.core.dex.attributes.nodes.LoopLabelAttr;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.info.MethodInfo;
+import jadx.core.dex.instructions.InvokeNode;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.instructions.args.CodeVar;
+import jadx.core.dex.instructions.args.InsnArg;
+import jadx.core.dex.instructions.args.InsnWrapArg;
+import jadx.core.dex.instructions.args.NamedArg;
+import jadx.core.dex.instructions.args.RegisterArg;
+import jadx.core.dex.instructions.args.SSAVar;
+import jadx.core.dex.instructions.mods.ConstructorInsn;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.InsnNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.utils.StringUtils;
+import jadx.core.utils.Utils;
+
+public class NameGen {
+
+	private static final Map<String, String> OBJ_ALIAS;
+
+	private final Set<String> varNames = new HashSet<>();
+	private final MethodNode mth;
+	private final boolean fallback;
+
+	static {
+		OBJ_ALIAS = Utils.newConstStringMap(
+				Consts.CLASS_STRING, "str",
+				Consts.CLASS_CLASS, "cls",
+				Consts.CLASS_THROWABLE, "th",
+				Consts.CLASS_OBJECT, "obj",
+				"java.util.Iterator", "it",
+				"java.lang.Boolean", "bool",
+				"java.lang.Short", "sh",
+				"java.lang.Integer", "num",
+				"java.lang.Character", "ch",
+				"java.lang.Byte", "b",
+				"java.lang.Float", "f",
+				"java.lang.Long", "l",
+				"java.lang.Double", "d",
+				"java.lang.StringBuilder", "sb",
+				"java.lang.Exception", "exc");
+	}
+
+	public NameGen(MethodNode mth, ClassGen classGen) {
+		this.mth = mth;
+		this.fallback = classGen.isFallbackMode();
+		NameGen outerNameGen = classGen.getOuterNameGen();
+		if (outerNameGen != null) {
+			inheritUsedNames(outerNameGen);
+		}
+		addNamesUsedInClass();
+	}
+
+	public void inheritUsedNames(NameGen otherNameGen) {
+		varNames.addAll(otherNameGen.varNames);
+	}
+
+	private void addNamesUsedInClass() {
+		ClassNode parentClass = mth.getParentClass();
+		for (FieldNode field : parentClass.getFields()) {
+			if (field.isStatic()) {
+				varNames.add(field.getAlias());
+			}
+		}
+		for (ClassNode innerClass : parentClass.getInnerClasses()) {
+			varNames.add(innerClass.getClassInfo().getAliasShortName());
+		}
+		// add all root package names to avoid collisions with full class names
+		varNames.addAll(mth.root().getCacheStorage().getRootPkgs());
+	}
+
+	public String assignArg(CodeVar var) {
+		if (fallback) {
+			return getFallbackName(var);
+		}
+		if (var.isThis()) {
+			return RegisterArg.THIS_ARG_NAME;
+		}
+		String name = getUniqueVarName(makeArgName(var));
+		var.setName(name);
+		return name;
+	}
+
+	public String assignNamedArg(NamedArg arg) {
+		String name = arg.getName();
+		if (fallback) {
+			return name;
+		}
+		name = getUniqueVarName(name);
+		arg.setName(name);
+		return name;
+	}
+
+	public String useArg(RegisterArg arg) {
+		String name = arg.getName();
+		if (name == null || fallback) {
+			return getFallbackName(arg);
+		}
+		return name;
+	}
+
+	// TODO: avoid name collision with variables names
+	public String getLoopLabel(LoopLabelAttr attr) {
+		String name = "loop" + attr.getLoop().getId();
+		varNames.add(name);
+		return name;
+	}
+
+	private String getUniqueVarName(String name) {
+		String r = name;
+		int i = 2;
+		while (varNames.contains(r)) {
+			r = name + i;
+			i++;
+		}
+		varNames.add(r);
+		return r;
+	}
+
+	private String makeArgName(CodeVar var) {
+		String name = var.getName();
+		if (name == null) {
+			name = guessName(var);
+		}
+		if (!NameMapper.isValidAndPrintable(name)) {
+			name = getFallbackName(var);
+		}
+		return name;
+	}
+
+	private String getFallbackName(CodeVar var) {
+		List<SSAVar> ssaVars = var.getSsaVars();
+		if (ssaVars.isEmpty()) {
+			return "v";
+		}
+		return getFallbackName(ssaVars.get(0).getAssign());
+	}
+
+	private String getFallbackName(RegisterArg arg) {
+		return "r" + arg.getRegNum();
+	}
+
+	private String guessName(CodeVar var) {
+		List<SSAVar> ssaVars = var.getSsaVars();
+		if (ssaVars != null && !ssaVars.isEmpty()) {
+			// TODO: use all vars for better name generation
+			SSAVar ssaVar = ssaVars.get(0);
+			if (ssaVar != null && ssaVar.getName() == null) {
+				RegisterArg assignArg = ssaVar.getAssign();
+				InsnNode assignInsn = assignArg.getParentInsn();
+				if (assignInsn != null) {
+					String name = makeNameFromInsn(assignInsn);
+					if (name != null && !NameMapper.isReserved(name)) {
+						assignArg.setName(name);
+						return name;
+					}
+				}
+			}
+		}
+		return makeNameForType(var.getType());
+	}
+
+	private String makeNameForType(ArgType type) {
+		if (type.isPrimitive()) {
+			return makeNameForPrimitive(type);
+		}
+		if (type.isArray()) {
+			return makeNameForType(type.getArrayRootElement()) + "Arr";
+		}
+		return makeNameForObject(type);
+	}
+
+	private static String makeNameForPrimitive(ArgType type) {
+		return type.getPrimitiveType().getShortName().toLowerCase();
+	}
+
+	private String makeNameForObject(ArgType type) {
+		if (type.isGenericType()) {
+			return StringUtils.escape(type.getObject().toLowerCase());
+		}
+		if (type.isObject()) {
+			String alias = getAliasForObject(type.getObject());
+			if (alias != null) {
+				return alias;
+			}
+			ClassInfo extClsInfo = ClassInfo.fromType(mth.root(), type);
+			String shortName = extClsInfo.getShortName();
+			String vName = fromName(shortName);
+			if (vName != null) {
+				return vName;
+			}
+			if (shortName != null) {
+				return StringUtils.escape(shortName.toLowerCase());
+			}
+		}
+		return StringUtils.escape(type.toString());
+	}
+
+	private static String fromName(String name) {
+		if (name == null || name.isEmpty()) {
+			return null;
+		}
+		if (name.toUpperCase().equals(name)) {
+			// all characters are upper case
+			return name.toLowerCase();
+		}
+		String v1 = Character.toLowerCase(name.charAt(0)) + name.substring(1);
+		if (!v1.equals(name)) {
+			return v1;
+		}
+		if (name.length() < 3) {
+			return name + "Var";
+		}
+		return null;
+	}
+
+	private static String getAliasForObject(String name) {
+		return OBJ_ALIAS.get(name);
+	}
+
+	private String makeNameFromInsn(InsnNode insn) {
+		switch (insn.getType()) {
+			case INVOKE:
+				InvokeNode inv = (InvokeNode) insn;
+				return makeNameFromInvoke(inv.getCallMth());
+
+			case CONSTRUCTOR:
+				ConstructorInsn co = (ConstructorInsn) insn;
+				return makeNameForObject(co.getClassType().getType());
+
+			case ARRAY_LENGTH:
+				return "length";
+
+			case ARITH:
+			case TERNARY:
+			case CAST:
+				for (InsnArg arg : insn.getArguments()) {
+					if (arg.isInsnWrap()) {
+						InsnNode wrapInsn = ((InsnWrapArg) arg).getWrapInsn();
+						String wName = makeNameFromInsn(wrapInsn);
+						if (wName != null) {
+							return wName;
+						}
+					}
+				}
+				break;
+
+			default:
+				break;
+		}
+		return null;
+	}
+
+	private String makeNameFromInvoke(MethodInfo callMth) {
+		String name = callMth.getName();
+		if (name.startsWith("get") || name.startsWith("set")) {
+			return fromName(name.substring(3));
+		}
+		if ("iterator".equals(name)) {
+			return "it";
+		}
+		ArgType declType = callMth.getDeclClass().getType();
+		if ("toString".equals(name)) {
+			return makeNameForType(declType);
+		}
+		if ("forName".equals(name) && declType.equals(ArgType.CLASS)) {
+			return OBJ_ALIAS.get(Consts.CLASS_CLASS);
+		}
+		if (name.startsWith("to")) {
+			return fromName(name.substring(2));
+		}
+		return name;
+	}
+}