build: fix release build

* fix: don't stop loading classes in case of an error
* style: reformat code

.codecov.yml

@@ -0,0 +1,14 @@
+coverage:
+  precision: 2
+  round: down
+  range: "50...100"
+
+  status:
+    project:
+      default: on
+    patch:
+      default: on
+    changes:
+      default: off
+
+comment: false

.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,22 @@
+---
+name: Decompilation error
+about: Create a report to help us improve jadx decompiler
+title: "[core]"
+labels: Core, bug
+assignees: ''
+
+---
+
+**Checks before report**
+- check [latest unstable build](https://bintray.com/skylot/jadx/unstable/_latestVersion#files) (maybe issue already fixed)
+- check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+- search existing issues by exception message
+
+**Describe error**
+- provide full name of method or class with error
+- provide full java stacktrace
+
+  **Note**: no need to copy method fallback code (commented pseudocode)
+- 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](../CONTRIBUTING.md#Pull-Request-Process)
+
+### Description
+Please describe your pull request.
+Reference issue it fix.

.gitignore

@@ -9,14 +9,20 @@ out/
 *.iml
 *.ipr
 *.iws
+.attach_pid*
+*.hprof
+
+**/.DS_Store
 
 bin/
 target/
 build/
+classes/
 idea/
 .gradle/
-gradle.properties
+node_modules/
 
+jadx-output/
 *-tmp/
 
 *.dex
@@ -24,4 +30,4 @@ gradle.properties
 *.dump
 *.log
 *.cfg
-
+*.orig

.gitlab-ci.yml

@@ -0,0 +1,37 @@
+variables:
+  GRADLE_OPTS: "-Dorg.gradle.daemon=false"
+  TERM: "dumb"
+
+before_script:
+  - chmod +x gradlew
+
+stages:
+  - test
+  - check
+
+java-8:
+  stage: test
+  image: openjdk:8
+  script: ./gradlew clean build
+
+java-11:
+  stage: test
+  image: openjdk:11
+  script: ./gradlew clean build
+
+java-12:
+  stage: test
+  image: gradle:jdk12 # latest gradle and jdk12
+  script: gradle clean build
+
+check:
+  stage: check
+  image: openjdk:8
+  script:
+    - export JADX_LAST_TAG="$(git describe --abbrev=0 --tags)"
+    - export JADX_VERSION="${JADX_LAST_TAG:1}-dev-$(git rev-parse --short HEAD)"
+    - ./gradlew clean sonarqube -Dsonar.host.url="${SONAR_HOST}" -Dsonar.projectKey=jadx -Dsonar.organization="${SONAR_ORG}" -Dsonar.login="${SONAR_TOKEN}" -Dsonar.branch.name=dev || echo "Skip sonar build and upload"
+    - ./gradlew clean dist
+  artifacts:
+    paths:
+      - build/jadx*.zip

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "jadx-test-app/test-app"]
-	path = jadx-test-app/test-app
-	url = git://github.com/skylot/jadx-test-app.git

.releaserc.yml

@@ -0,0 +1,35 @@
+branch: release
+verifyConditions:
+  - '@semantic-release/github'
+
+prepare:
+  - path: '@semantic-release/exec'
+    cmd: "JADX_VERSION=${nextRelease.version} ./gradlew clean dist"
+
+preset: "angular"
+
+generateNotes:
+  - path: '@semantic-release/release-notes-generator'
+    writerOpts:
+      groupBy: "type"
+      commitGroupsSort:
+        - "feat"
+        - "perf"
+        - "fix"
+      commitsSort: "header"
+
+publish:
+  - path: '@semantic-release/exec'
+    cmd: "JADX_VERSION=${nextRelease.version} BINTRAY_PACKAGE=releases bash scripts/bintray-upload.sh"
+  - path: '@semantic-release/github'
+    assets:
+      - path: 'build/*.zip'
+      - path: 'build/*.exe'
+
+success:
+  - path: '@semantic-release/github'
+    successComment: false
+
+fail:
+  - path: '@semantic-release/github'
+    failComment: false

.travis.yml

@@ -1,28 +1,41 @@
 language: java
-jdk:
-    - oraclejdk8
-    - oraclejdk7
-    - openjdk6
+os: linux
+dist: trusty
+
+# don't build on tag push
+if: tag IS blank
+
+git:
+  depth: false
 
 before_install:
-    - chmod +x gradlew
+  - chmod +x gradlew
 
-script:
-    - TERM=dumb ./gradlew clean build dist
+# override install to skip 'gradle assemble'
+install: true
 
-after_success:
-    - TERM=dumb ./gradlew jacocoTestReport coveralls
+env:
+  global:
+    - TERM=dumb
+    - JADX_LAST_TAG=$(git describe --abbrev=0 --tags)
+    - JADX_VERSION="${JADX_LAST_TAG:1}-b$TRAVIS_BUILD_NUMBER-$(git rev-parse --short HEAD)"
 
-sudo: false
+jdk:
+  - openjdk8
+  - openjdk11
 
-cache:
-    directories:
-        - $HOME/.gradle/caches/
-        - $HOME/.gradle/wrapper/
+script: ./gradlew clean build
 
-before_cache:
-    - rm -f $HOME/.gradle/caches/modules-2/modules-2.lock
+jobs:
+  include:
+    - stage: deploy-unstable
+      jdk: openjdk8
+      if: branch = master AND repo = env(MAIN_REPO) AND type = push
+      script: bash scripts/travis-master.sh
 
-notifications:
-    email:
-        - skylot@gmail.com
+    - stage: deploy-release
+      language: node_js
+      jdk: openjdk8
+      node_js: 11
+      if: branch = release AND repo = env(MAIN_REPO) AND type = push
+      script: bash scripts/travis-release.sh

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,34 @@
+# 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 [latest unstable build](https://bintray.com/skylot/jadx/unstable/_latestVersion#files) (maybe issue already fixed)
+    - 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
+    - provide full name of method or class with error
+    - provide full java stacktrace
+
+      **Note**: no need to copy method fallback code (commented pseudocode)
+    - 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 open a 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`

README.md

@@ -1,93 +1,125 @@
 ## JADX
 
 [![Build Status](https://travis-ci.org/skylot/jadx.png?branch=master)](https://travis-ci.org/skylot/jadx)
-[![Build Status](https://drone.io/github.com/skylot/jadx/status.png)](https://drone.io/github.com/skylot/jadx/latest)
-[![Coverage Status](https://coveralls.io/repos/skylot/jadx/badge.png)](https://coveralls.io/r/skylot/jadx)
-[![Coverity Scan Build Status](https://scan.coverity.com/projects/2166/badge.svg)](https://scan.coverity.com/projects/2166)
+[![Code Coverage](https://codecov.io/gh/skylot/jadx/branch/master/graph/badge.svg)](https://codecov.io/gh/skylot/jadx)
+[![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/)
+[![SonarQube Bugs](https://sonarcloud.io/api/project_badges/measure?project=jadx&metric=bugs)](https://sonarcloud.io/dashboard?id=jadx)
 [![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)
+[![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)
 
 **jadx** - Dex to Java decompiler
 
 Command line and GUI tools for produce Java source code from Android Dex and Apk files
 
-![jadx-gui screenshot](http://skylot.github.io/jadx/jadx-gui.png)
+**Main features:**
+- decompile Dalvik bytecode to java classes from APK, dex, aar and zip files
+- decode `AndroidManifest.xml` and other resources from `resources.arsc`
+- deobfuscator included
 
-### Downloads
-- [unstable](https://drone.io/github.com/skylot/jadx/files)
-- from [github](https://github.com/skylot/jadx/releases)
-- from [sourceforge](http://sourceforge.net/projects/jadx/files/)
+**jadx-gui features:**
+- view decompiled code with highlighted syntax
+- jump to declaration
+- find usage
+- full text search
+
+See these features in action here: [jadx-gui features overview](https://github.com/skylot/jadx/wiki/jadx-gui-features-overview)
 
 
-### Building from source
-    git clone https://github.com/skylot/jadx.git
-    cd jadx
-    ./gradlew dist
+![jadx-gui screenshot](https://i.imgur.com/h917IBZ.png)
+
+
+### Download
+- latest [unstable build: ![Download](https://api.bintray.com/packages/skylot/jadx/unstable/images/download.svg) ](https://bintray.com/skylot/jadx/unstable/_latestVersion#files)
+- release from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
+- release from [bintray: ![Download](https://api.bintray.com/packages/skylot/jadx/releases/images/download.svg) ](https://bintray.com/skylot/jadx/releases/_latestVersion#files)
+
+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 8 or later 64-bit version.
+For windows you can download it from [adoptopenjdk.net](https://adoptopenjdk.net/releases.html?variant=openjdk11&jvmVariant=hotspot#x64_win) (select "Install JRE").
+
+### 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
+```
 
 (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, .jar or .class)
+jadx[-gui] [options] <input file> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc)
 options:
- -d, --output-dir           - output directory
- -j, --threads-count        - processing threads count
- -r, --no-res               - do not decode resources
- -s, --no-src               - do not decompile source code
- -e, --export-gradle        - save as android gradle project
-     --show-bad-code        - show inconsistent code (incorrectly decompiled)
-     --no-replace-consts    - don't replace constant value with matching constant field
-     --escape-unicode       - escape non latin characters in strings (with \u)
-     --deobf                - activate deobfuscation
-     --deobf-min            - min length of name
-     --deobf-max            - max length of name
-     --deobf-rewrite-cfg    - force to save deobfuscation map
-     --deobf-use-sourcename - use source file name as class name alias
-     --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)
- -v, --verbose              - verbose output
- -h, --help                 - print this help
+  -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
+  --no-inline-anonymous               - disable anonymous classes 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-rewrite-cfg                 - force to save deobfuscation map
+  --deobf-use-sourcename              - use source file name as class name alias
+  --rename-flags                      - what to rename, comma-separated, 'case' for system case sensitivity, 'valid' for java identifiers, 'printable' characters, 'none' or '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)
+  -v, --verbose                       - verbose output (set --log-level to DEBUG)
+  -q, --quiet                         - turn off output (set --log-level to QUIET)
+  --log-level                         - set log level, values: QUIET, PROGRESS, ERROR, WARN, INFO, DEBUG, default: PROGRESS
+  --version                           - print jadx version
+  -h, --help                          - print this help
 Example:
  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
-##### Out of memory error:
-  - Reduce processing threads count (`-j` option)
-  - Increase maximum java heap size:
-    * command line (example for linux):
-      `JAVA_OPTS="-Xmx4G" jadx -j 1 some.apk`
-    * edit 'jadx' script (jadx.bat on Windows) and setup bigger heap size:
-      `DEFAULT_JVM_OPTS="-Xmx2500M"`
-
-
-### Contribution
+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 bug using one of following patterns:
-    * Java code examples which decompiles incorrectly
-    * Error log and link to _public available_ apk file or app page on Google play
+  - 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)
 
-And any other comments will be very helpfull,
-because at current stage of development it is very time consuming
-to **find** new bugs, design and implement new features.
-Also I need to **prioritize** these task for complete most important at first.
+### Related projects:
+- [PyJadx](https://github.com/romainthomas/pyjadx) - python binding for jadx by [@romainthomas](https://github.com/romainthomas)
 
 ---------------------------------------
 *Licensed under the Apache 2.0 License*
 
-*Copyright 2015 by Skylot*
+*Copyright 2019 by Skylot*

build.gradle

@@ -1,102 +1,161 @@
-buildscript {
-    repositories {
-        mavenCentral()
-        jcenter()
-    }
-}
-
 plugins {
-    id "com.github.kt3k.coveralls" version "2.3.1"
-    id "info.solidsoft.pitest" version "1.1.4"
-//    id "com.github.ben-manes.versions" version "0.8"
+	id 'org.sonarqube' version '2.8'
+	id 'com.github.ben-manes.versions' version '0.27.0'
+	id "com.diffplug.gradle.spotless" version "3.26.0"
 }
 
-ext.jadxVersion = file('version').readLines().get(0)
+ext.jadxVersion = System.getenv('JADX_VERSION') ?: "dev"
 version = jadxVersion
+println("jadx version: ${jadxVersion}")
 
-subprojects {
-    apply plugin: 'java'
-    apply plugin: 'groovy'
-    apply plugin: 'jacoco'
-    apply plugin: 'com.github.kt3k.coveralls'
+allprojects {
+	apply plugin: 'java'
+	apply plugin: 'jacoco'
+	apply plugin: 'checkstyle'
 
-    version = jadxVersion
+	version = jadxVersion
 
-    tasks.withType(JavaCompile) {
-        sourceCompatibility = JavaVersion.VERSION_1_6
-        targetCompatibility = JavaVersion.VERSION_1_6
+	tasks.withType(JavaCompile) {
+		if (!"$it".contains(':jadx-samples:')) {
+			options.compilerArgs << '-Xlint' << '-Xlint:unchecked' << '-Xlint:deprecation'
+		}
+	}
 
-        if (!"$it".contains(':jadx-samples:')) {
-            options.compilerArgs << '-Xlint' << '-Xlint:unchecked' << '-Xlint:deprecation'
-        }
-    }
+	compileJava {
+		options.encoding = "UTF-8"
+	}
 
-    jar {
-        version = jadxVersion
-        manifest {
-            mainAttributes('jadx-version': jadxVersion)
-        }
-    }
+	jar {
+		version = jadxVersion
+		manifest {
+			mainAttributes('jadx-version': jadxVersion)
+		}
+	}
 
-    dependencies {
-        compile 'org.slf4j:slf4j-api:1.7.10'
+	dependencies {
+		compile 'org.slf4j:slf4j-api:1.7.29'
 
-        testCompile 'ch.qos.logback:logback-classic:1.1.2'
-        testCompile 'junit:junit:4.12'
-        testCompile 'org.hamcrest:hamcrest-library:1.3'
-        testCompile 'org.mockito:mockito-core:1.10.19'
-        testCompile 'org.spockframework:spock-core:1.0-groovy-2.4'
-        testCompile 'cglib:cglib-nodep:3.1'
-    }
+		testCompile 'ch.qos.logback:logback-classic:1.2.3'
+		testCompile 'org.hamcrest:hamcrest-library:2.2'
+		testCompile 'org.mockito:mockito-core:3.1.0'
+		testCompile 'org.assertj:assertj-core:3.14.0'
 
-    repositories {
-        mavenCentral()
-        mavenLocal()
-        jcenter()
-    }
+		testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.2'
+		testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.5.2'
 
-    jacocoTestReport {
-        reports {
-            xml.enabled = true // coveralls plugin depends on xml format report
-            html.enabled = true
-        }
-    }
+		testCompile 'org.eclipse.jdt.core.compiler:ecj:4.6.1'
+	}
+
+	test {
+		useJUnitPlatform()
+	}
+
+	repositories {
+		mavenLocal()
+		mavenCentral()
+		jcenter()
+		google()
+	}
+
+	jacoco {
+		toolVersion = "0.8.2"
+	}
+	jacocoTestReport {
+		reports {
+			xml.enabled = true
+			html.enabled = true
+		}
+	}
+
+	checkstyleMain {
+		// exclude all sources in samples module
+		exclude '**/samples/**'
+	}
+}
+
+sonarqube {
+	properties {
+		property 'sonar.exclusions', '**/jadx/samples/**/*,**/test-app/**/*'
+		property 'sonar.coverage.exclusions', '**/jadx/gui/**/*'
+	}
+}
+
+spotless {
+	java {
+		target fileTree(rootDir).matching {
+			include 'jadx-cli/src/**/java/**/*.java'
+			include 'jadx-core/src/**/java/**/*.java'
+			include 'jadx-gui/src/**/java/**/*.java'
+		}
+
+		importOrderFile 'config/code-formatter/eclipse.importorder'
+		eclipse().configFile 'config/code-formatter/eclipse.xml'
+		removeUnusedImports()
+
+		lineEndings(com.diffplug.spotless.LineEnding.UNIX)
+		encoding("UTF-8")
+		trimTrailingWhitespace()
+		endWithNewline()
+	}
+	format 'misc', {
+		target '**/*.gradle', '**/*.md', '**/*.xml', '**/.gitignore', '**/.properties'
+		targetExclude ".gradle/**", ".idea/**"
+
+		lineEndings(com.diffplug.spotless.LineEnding.UNIX)
+		encoding("UTF-8")
+		trimTrailingWhitespace()
+		endWithNewline()
+	}
+}
+
+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 copyArtifacts(type: Sync, dependsOn: ['jadx-cli:installDist', 'jadx-gui:installDist']) {
-    destinationDir file("$buildDir/jadx")
-    ['jadx-cli', 'jadx-gui'].each {
-        from tasks.getByPath(":${it}:installDist").destinationDir
-    }
+	destinationDir file("$buildDir/jadx")
+	['jadx-cli', 'jadx-gui'].each {
+		from tasks.getByPath(":${it}:installDist").destinationDir
+	}
 }
 
 task pack(type: Zip, dependsOn: copyArtifacts) {
-    destinationDir buildDir
-    archiveName "jadx-${jadxVersion}.zip"
-    from copyArtifacts.destinationDir
+	destinationDir buildDir
+	archiveName "jadx-${jadxVersion}.zip"
+	from copyArtifacts.destinationDir
 }
 
-task dist(dependsOn: pack) {
-    description = 'Build jadx distribution zip'
+task copyExe(type: Copy, dependsOn: 'jadx-gui:createExe') {
+	group 'jadx'
+	description = 'Copy exe to build dir'
+	destinationDir buildDir
+	from tasks.getByPath('jadx-gui:createExe').outputs
+	include '*.exe'
+}
+
+task dist(dependsOn: [pack, copyExe]) {
+	group 'jadx'
+	description = 'Build jadx distribution zip'
 }
 
 task samples(dependsOn: 'jadx-samples:samples') {
-}
-
-task testAppCheck(dependsOn: 'jadx-test-app:testAppCheck') {
-}
-
-task pitest(overwrite: true, dependsOn: 'jadx-core:pitest') {
+	group 'jadx'
 }
 
 task cleanBuildDir(type: Delete) {
-    delete buildDir
+	group 'jadx'
+	delete buildDir
 }
 
-build.dependsOn(dist, samples)
+test.dependsOn(samples)
 
 clean.dependsOn(cleanBuildDir)
-
-task wrapper(type: Wrapper) {
-    gradleVersion = '2.7'
-}

config/checkstyle/checkstyle.xml

@@ -0,0 +1,126 @@
+<?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>
+
+	<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 @@
+org.gradle.daemon=false

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.7-bin.zip

gradlew

@@ -1,4 +1,20 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or 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.
+#
 
 ##############################################################################
 ##
@@ -6,47 +22,6 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# 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
-    ;;
-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"
@@ -61,9 +36,49 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
+cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$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"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -90,7 +105,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -110,10 +125,11 @@ 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
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -138,27 +154,30 @@ if $cygwin ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=$((i+1))
+        i=`expr $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" ;;
+        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" ;;
     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=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=`save "$@"`
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+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,14 +24,14 @@
 @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 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
 
@@ -46,10 +62,9 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows 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.
@@ -60,11 +75,6 @@ set _SKIP=2
 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

jadx-cli/build.gradle

@@ -1,20 +1,24 @@
-apply plugin: 'application'
-
-mainClassName = 'jadx.cli.JadxCLI'
-applicationName = 'jadx'
+plugins {
+	id 'application'
+}
 
 dependencies {
-    compile(project(':jadx-core'))
-    compile 'com.beust:jcommander:1.47'
-    compile 'ch.qos.logback:logback-classic:1.1.2'
+	compile(project(':jadx-core'))
+	compile 'com.beust:jcommander:1.78'
+	compile 'ch.qos.logback:logback-classic:1.2.3'
+}
+
+application {
+	applicationName = 'jadx'
+	mainClassName = 'jadx.cli.JadxCLI'
+	applicationDefaultJvmArgs = ['-Xms128M', '-Xmx4g', '-XX:+UseG1GC']
 }
 
 applicationDistribution.with {
-    into('') {
-        from '../.'
-        include 'README.md'
-        include 'NOTICE'
-        include 'LICENSE'
-    }
+	into('') {
+		from '../.'
+		include 'README.md'
+		include 'NOTICE'
+		include 'LICENSE'
+	}
 }
-

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

@@ -0,0 +1,137 @@
+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.LinkedList;
+import java.util.List;
+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());
+			addSpaces(opt, maxNamesLen - opt.length() + 3);
+			opt.append("- ").append(p.getDescription());
+			String defaultValue = getDefaultValue(args, f, opt);
+			if (defaultValue != null) {
+				opt.append(", default: ").append(defaultValue);
+			}
+			out.println(opt);
+		}
+		out.println("Example:");
+		out.println("  jadx -d out classes.dex");
+	}
+
+	/**
+	 * Get all declared fields of the specified class and all super classes
+	 *
+	 * @param clazz
+	 * @return
+	 */
+	private List<Field> getFields(Class<?> clazz) {
+		List<Field> fieldList = new LinkedList<>();
+		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();
+				}
+			}
+		} 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,49 @@
 package jadx.cli;
 
-import jadx.api.JadxDecompiler;
-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.core.utils.exceptions.JadxArgsValidateException;
+
 public class JadxCLI {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxCLI.class);
 
-	public static void main(String[] args) throws JadxException {
+	public static void main(String[] args) {
+		int result = 0;
 		try {
 			JadxCLIArgs jadxArgs = new JadxCLIArgs();
-			if (processArgs(jadxArgs, args)) {
-				processAndSave(jadxArgs);
+			if (jadxArgs.processArgs(args)) {
+				result = processAndSave(jadxArgs);
 			}
-		} catch (Throwable e) {
+		} catch (Exception e) {
 			LOG.error("jadx error: {}", e.getMessage(), e);
-			System.exit(1);
+			result = 1;
+		} finally {
+			System.exit(result);
 		}
 	}
 
-	static void processAndSave(JadxCLIArgs jadxArgs) throws JadxException {
-		JadxDecompiler jadx = new JadxDecompiler(jadxArgs);
-		jadx.setOutputDir(jadxArgs.getOutDir());
-		jadx.loadFiles(jadxArgs.getInput());
+	static int processAndSave(JadxCLIArgs inputArgs) {
+		JadxArgs args = inputArgs.toJadxArgs();
+		args.setCodeCache(new NoOpCodeCache());
+		JadxDecompiler jadx = new JadxDecompiler(args);
+		try {
+			jadx.load();
+		} catch (JadxArgsValidateException e) {
+			LOG.error("Incorrect arguments: {}", e.getMessage());
+			return 1;
+		}
 		jadx.save();
-		if (jadx.getErrorsCount() != 0) {
+		int errorsCount = jadx.getErrorsCount();
+		if (errorsCount != 0) {
 			jadx.printErrorsReport();
-			LOG.error("finished with errors");
+			LOG.error("finished with errors, count: {}", errorsCount);
 		} else {
 			LOG.info("done");
 		}
-	}
-
-	static boolean processArgs(JadxCLIArgs jadxArgs, String[] args) throws JadxException {
-		if (!jadxArgs.processArgs(args)) {
-			return false;
-		}
-		if (jadxArgs.getInput().isEmpty()) {
-			LOG.error("Please specify input file");
-			jadxArgs.printUsage();
-			return false;
-		}
-		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);
-			} else {
-				outDirName = name + "-jadx-out";
-			}
-			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 true;
+		return 0;
 	}
 }

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

@@ -1,292 +1,352 @@
 package jadx.cli;
 
-import ch.qos.logback.classic.spi.ILoggingEvent;
-import ch.qos.logback.core.Appender;
-import jadx.api.IJadxArgs;
-import jadx.api.JadxDecompiler;
-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.LinkedHashMap;
+import java.util.Arrays;
+import java.util.EnumSet;
 import java.util.List;
-import java.util.Map;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.Locale;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import com.beust.jcommander.IStringConverter;
-import com.beust.jcommander.JCommander;
 import com.beust.jcommander.Parameter;
-import com.beust.jcommander.ParameterDescription;
-import com.beust.jcommander.ParameterException;
 
-public class JadxCLIArgs implements IJadxArgs {
+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, .jar or .class)")
-	protected List<String> files;
+public class JadxCLIArgs {
 
-	@Parameter(names = {"-d", "--output-dir"}, description = "output directory")
-	protected String outDirName;
+	@Parameter(description = "<input file> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc)")
+	protected List<String> files = new ArrayList<>(1);
 
-	@Parameter(names = {"-j", "--threads-count"}, description = "processing threads count")
-	protected int threadsCount = Math.max(1, Runtime.getRuntime().availableProcessors() / 2);
+	@Parameter(names = { "-d", "--output-dir" }, description = "output directory")
+	protected String outDir;
 
-	@Parameter(names = {"-r", "--no-res"}, description = "do not decode resources")
+	@Parameter(names = { "-ds", "--output-dir-src" }, description = "output directory for sources")
+	protected String outDirSrc;
+
+	@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")
+	@Parameter(names = { "-s", "--no-src" }, description = "do not decompile source code")
 	protected boolean skipSources = false;
 
-	@Parameter(names = {"-e", "--export-gradle"}, description = "save as android gradle project")
+	@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 = {"--show-bad-code"}, description = "show inconsistent code (incorrectly decompiled)")
+	@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-replace-consts", converter = InvertedBooleanConverter.class,
-			description = "don't replace constant value with matching constant field")
+	@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 = { "--no-inline-anonymous" }, description = "disable anonymous classes inline")
+	protected boolean inlineAnonymousClasses = 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)")
+	@Parameter(names = { "--escape-unicode" }, description = "escape non latin characters in strings (with \\u)")
 	protected boolean escapeUnicode = false;
 
-	@Parameter(names = {"--deobf"}, description = "activate deobfuscation")
+	@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")
-	protected int deobfuscationMinLength = 2;
+	@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")
+	@Parameter(names = { "--deobf-max" }, description = "max length of name, renamed if longer")
 	protected int deobfuscationMaxLength = 64;
 
-	@Parameter(names = {"--deobf-rewrite-cfg"}, description = "force to save deobfuscation map")
+	@Parameter(names = { "--deobf-rewrite-cfg" }, description = "force to save deobfuscation map")
 	protected boolean deobfuscationForceSave = false;
 
-	@Parameter(names = {"--deobf-use-sourcename"}, description = "use source file name as class name alias")
+	@Parameter(names = { "--deobf-use-sourcename" }, description = "use source file name as class name alias")
 	protected boolean deobfuscationUseSourceNameAsAlias = false;
 
-	@Parameter(names = {"--cfg"}, description = "save methods control flow graph to dot file")
+	@Parameter(
+			names = { "--rename-flags" },
+			description = "what to rename, comma-separated,"
+					+ " 'case' for system case sensitivity,"
+					+ " 'valid' for java identifiers,"
+					+ " 'printable' characters,"
+					+ " 'none' or '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 = {"-f", "--fallback"}, description = "make simple dump (using goto instead of 'if', 'for', etc)")
+	@Parameter(names = { "-f", "--fallback" }, description = "make simple dump (using goto instead of 'if', 'for', etc)")
 	protected boolean fallbackMode = false;
 
-	@Parameter(names = {"-v", "--verbose"}, description = "verbose output")
+	@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 = { "--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 = { "--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 boolean processArgs(String[] args) {
-		return parse(args) && process();
+		JCommanderWrapper<JadxCLIArgs> jcw = new JCommanderWrapper<>(this);
+		return jcw.parse(args) && process(jcw);
 	}
 
-	private boolean parse(String[] args) {
-		try {
-			new JCommander(this, args);
-			return true;
-		} catch (ParameterException e) {
-			System.err.println("Arguments parse error: " + e.getMessage());
-			printUsage();
+	/**
+	 * 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);
 	}
 
-	private boolean process() {
-		if (isPrintHelp()) {
-			printUsage();
+	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);
-				// remove INFO ThresholdFilter
-				Appender<ILoggingEvent> appender = rootLogger.getAppender("STDOUT");
-				if (appender != null) {
-					appender.clearAllFilters();
-				}
+				throw new JadxException("Threads count must be positive, got: " + threadsCount);
 			}
+			LogHelper.setLogLevelFromArgs(this);
 		} catch (JadxException e) {
 			System.err.println("ERROR: " + e.getMessage());
-			printUsage();
+			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: " + 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<String, ParameterDescription>(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;
-			}
+	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 = JadxCLIArgs.class.getDeclaredFields();
-		for (Field f : fields) {
-			String name = f.getName();
-			ParameterDescription p = paramsMap.get(name);
-			if (p == null) {
-				continue;
-			}
-			StringBuilder opt = new StringBuilder();
-			opt.append(' ').append(p.getNames());
-			addSpaces(opt, maxNamesLen - opt.length() + 2);
-			opt.append("- ").append(p.getDescription());
-			out.println(opt);
-		}
-		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.setDeobfuscationForceSave(deobfuscationForceSave);
+		args.setDeobfuscationMinLength(deobfuscationMinLength);
+		args.setDeobfuscationMaxLength(deobfuscationMaxLength);
+		args.setUseSourceNameAsClassAlias(deobfuscationUseSourceNameAsAlias);
+		args.setEscapeUnicode(escapeUnicode);
+		args.setRespectBytecodeAccModifiers(respectBytecodeAccessModifiers);
+		args.setExportAsGradleProject(exportAsGradleProject);
+		args.setUseImports(useImports);
+		args.setDebugInfo(debugInfo);
+		args.setInlineAnonymousClasses(inlineAnonymousClasses);
+		args.setRenameCaseSensitive(isRenameCaseSensitive());
+		args.setRenameValid(isRenameValid());
+		args.setRenamePrintable(isRenamePrintable());
+		args.setFsCaseSensitive(fsCaseSensitive);
+		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 static class InvertedBooleanConverter implements IStringConverter<Boolean> {
-		@Override
-		public Boolean convert(String value) {
-			return "false".equals(value);
-		}
+	public String getOutDir() {
+		return outDir;
 	}
 
-	public List<File> getInput() {
-		return input;
+	public String getOutDirSrc() {
+		return outDirSrc;
 	}
 
-	@Override
-	public File getOutDir() {
-		return outputDir;
+	public String getOutDirRes() {
+		return outDirRes;
 	}
 
-	public void setOutputDir(File outputDir) {
-		this.outputDir = outputDir;
-	}
-
-	public boolean isPrintHelp() {
-		return printHelp;
-	}
-
-	@Override
 	public boolean isSkipResources() {
 		return skipResources;
 	}
 
-	@Override
 	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 isShowInconsistentCode() {
 		return showInconsistentCode;
 	}
 
-	@Override
-	public boolean isVerbose() {
-		return verbose;
+	public boolean isUseImports() {
+		return useImports;
+	}
+
+	public boolean isDebugInfo() {
+		return debugInfo;
+	}
+
+	public boolean isInlineAnonymousClasses() {
+		return inlineAnonymousClasses;
 	}
 
-	@Override
 	public boolean isDeobfuscationOn() {
 		return deobfuscationOn;
 	}
 
-	@Override
 	public int getDeobfuscationMinLength() {
 		return deobfuscationMinLength;
 	}
 
-	@Override
 	public int getDeobfuscationMaxLength() {
 		return deobfuscationMaxLength;
 	}
 
-	@Override
 	public boolean isDeobfuscationForceSave() {
 		return deobfuscationForceSave;
 	}
 
-	@Override
-	public boolean useSourceNameAsClassAlias() {
+	public boolean isDeobfuscationUseSourceNameAsAlias() {
 		return deobfuscationUseSourceNameAsAlias;
 	}
 
-	@Override
-	public boolean escapeUnicode() {
+	public boolean isEscapeUnicode() {
 		return escapeUnicode;
 	}
 
-	@Override
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public boolean isRawCfgOutput() {
+		return rawCfgOutput;
+	}
+
 	public boolean isReplaceConsts() {
 		return replaceConsts;
 	}
 
-	@Override
+	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;
+	}
+
+	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.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 String enumValuesString(Enum<?>[] values) {
+		return Arrays.stream(values)
+				.map(v -> '\'' + v.name().toLowerCase(Locale.ROOT) + '\'')
+				.collect(Collectors.joining(", "));
+	}
 }

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

@@ -0,0 +1,93 @@
+package jadx.cli;
+
+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;
+		}
+	}
+
+	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) {
+		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);
+		}
+	}
+
+	private static void setLevelForClass(Class<?> cls, Level level) {
+		((Logger) LoggerFactory.getLogger(cls)).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/resources/logback.xml

@@ -1,16 +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">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>INFO</level>
-        </filter>
-        <encoder>
-            <pattern>%d{HH:mm:ss} %-5level - %msg%n</pattern>
-        </encoder>
-    </appender>
-
-    <root level="DEBUG">
-        <appender-ref ref="STDOUT"/>
-    </root>
-
+	<root level="INFO">
+		<appender-ref ref="STDOUT"/>
+	</root>
 </configuration>

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

@@ -1,22 +1,67 @@
 package jadx.cli;
 
-import org.junit.Test;
+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;
-import static org.junit.Assert.assertThat;
 
 public class JadxCLIArgsTest {
 
+	private static final Logger LOG = LoggerFactory.getLogger(JadxCLIArgsTest.class);
+
 	@Test
-	public void testInvertedBooleanOption() throws Exception {
+	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) {
-		JadxCLIArgs jadxArgs = new JadxCLIArgs();
+		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,49 @@
+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-core/build.gradle

@@ -1,28 +1,18 @@
-ext.jadxClasspath = 'clsp-data/android-5.1.jar'
-
-apply plugin: "info.solidsoft.pitest"
-
 dependencies {
-    runtime files(jadxClasspath)
+	runtime files('clsp-data/android-29-clst.jar')
+	runtime files('clsp-data/android-29-res.jar')
 
-    compile files('lib/dx-1.10.jar')
-    compile 'commons-io:commons-io:2.4'
-    compile 'org.ow2.asm:asm:5.0.3'
-    compile 'com.intellij:annotations:12.0'
-    compile 'uk.com.robust-it:cloning:1.9.2'
+	compile files('lib/dx-1.16.jar') // TODO: dx don't support java version > 9 (53)
 
-    testCompile 'org.smali:smali:2.0.3'
-}
-
-task packTests(type: Jar) {
-    classifier = 'tests'
-    from sourceSets.test.output
-}
-
-pitest {
-    excludedMethods = ['toString']
-    threads = 4
-    enableDefaultIncrementalAnalysis = true
-    outputFormats = ['XML', 'HTML']
-    jvmArgs = ['-Xmx12G']
+	compile 'org.ow2.asm:asm:7.2'
+	compile 'org.jetbrains:annotations:18.0.0'
+	compile 'com.google.code.gson:gson:2.8.6'
+
+	compile 'org.smali:baksmali:2.3.4'
+	compile('org.smali:smali:2.3.4') {
+		exclude group: 'com.google.guava'
+	}
+	compile 'com.google.guava:guava:28.1-jre'
+
+	testCompile 'org.apache.commons:commons-lang3:3.9'
 }

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

@@ -57,6 +57,14 @@ public final class CodePosition {
 
 	@Override
 	public String toString() {
-		return line + ":" + offset + (node != null ? " " + node : "");
+		StringBuilder sb = new StringBuilder();
+		sb.append(line);
+		if (offset != 0) {
+			sb.append(':').append(offset);
+		}
+		if (node != null) {
+			sb.append(' ').append(node);
+		}
+		return sb.toString();
 	}
 }

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

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

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

@@ -0,0 +1,11 @@
+package jadx.api;
+
+import java.util.Map;
+
+public interface ICodeInfo {
+	String getCodeStr();
+
+	Map<Integer, Integer> getLineMapping();
+
+	Map<CodePosition, Object> getAnnotations();
+}

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

@@ -1,45 +0,0 @@
-package jadx.api;
-
-import java.io.File;
-
-public interface IJadxArgs {
-	File getOutDir();
-
-	int getThreadsCount();
-
-	boolean isCFGOutput();
-
-	boolean isRawCFGOutput();
-
-	boolean isFallbackMode();
-
-	boolean isShowInconsistentCode();
-
-	boolean isVerbose();
-
-	boolean isSkipResources();
-
-	boolean isSkipSources();
-
-	boolean isDeobfuscationOn();
-
-	int getDeobfuscationMinLength();
-
-	int getDeobfuscationMaxLength();
-
-	boolean isDeobfuscationForceSave();
-
-	boolean useSourceNameAsClassAlias();
-
-	boolean escapeUnicode();
-
-	/**
-	 * Replace constant values with static final fields with same value
-	 */
-	boolean isReplaceConsts();
-
-	/**
-	 * Save as gradle project
-	 */
-	boolean isExportAsGradleProject();
-}

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

@@ -1,24 +1,53 @@
 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.Predicate;
 
-public class JadxArgs implements IJadxArgs {
+import jadx.api.impl.InMemoryCodeCache;
 
-	private File outDir = new File("jadx-output");
-	private int threadsCount = Math.max(1, Runtime.getRuntime().availableProcessors() - 1);
+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 int threadsCount = DEFAULT_THREADS_COUNT;
 
 	private boolean cfgOutput = false;
 	private boolean rawCFGOutput = false;
 
-	private boolean isVerbose = false;
 	private boolean fallbackMode = false;
 	private boolean showInconsistentCode = false;
 
-	private boolean isSkipResources = false;
-	private boolean isSkipSources = false;
+	private boolean useImports = true;
+	private boolean debugInfo = true;
+	private boolean inlineAnonymousClasses = true;
 
-	private boolean isDeobfuscationOn = false;
-	private boolean isDeobfuscationForceSave = false;
+	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 int deobfuscationMinLength = 0;
@@ -26,9 +55,45 @@ public class JadxArgs implements IJadxArgs {
 
 	private boolean escapeUnicode = false;
 	private boolean replaceConsts = true;
+	private boolean respectBytecodeAccModifiers = false;
 	private boolean exportAsGradleProject = false;
 
-	@Override
+	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;
+
+	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;
 	}
@@ -37,7 +102,22 @@ public class JadxArgs implements IJadxArgs {
 		this.outDir = outDir;
 	}
 
-	@Override
+	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;
 	}
@@ -46,8 +126,7 @@ public class JadxArgs implements IJadxArgs {
 		this.threadsCount = threadsCount;
 	}
 
-	@Override
-	public boolean isCFGOutput() {
+	public boolean isCfgOutput() {
 		return cfgOutput;
 	}
 
@@ -55,7 +134,6 @@ public class JadxArgs implements IJadxArgs {
 		this.cfgOutput = cfgOutput;
 	}
 
-	@Override
 	public boolean isRawCFGOutput() {
 		return rawCFGOutput;
 	}
@@ -64,7 +142,6 @@ public class JadxArgs implements IJadxArgs {
 		this.rawCFGOutput = rawCFGOutput;
 	}
 
-	@Override
 	public boolean isFallbackMode() {
 		return fallbackMode;
 	}
@@ -73,7 +150,6 @@ public class JadxArgs implements IJadxArgs {
 		this.fallbackMode = fallbackMode;
 	}
 
-	@Override
 	public boolean isShowInconsistentCode() {
 		return showInconsistentCode;
 	}
@@ -82,53 +158,71 @@ public class JadxArgs implements IJadxArgs {
 		this.showInconsistentCode = showInconsistentCode;
 	}
 
-	@Override
-	public boolean isVerbose() {
-		return isVerbose;
+	public boolean isUseImports() {
+		return useImports;
 	}
 
-	public void setVerbose(boolean verbose) {
-		isVerbose = verbose;
+	public void setUseImports(boolean useImports) {
+		this.useImports = useImports;
+	}
+
+	public boolean isDebugInfo() {
+		return debugInfo;
+	}
+
+	public void setDebugInfo(boolean debugInfo) {
+		this.debugInfo = debugInfo;
+	}
+
+	public boolean isInlineAnonymousClasses() {
+		return inlineAnonymousClasses;
+	}
+
+	public void setInlineAnonymousClasses(boolean inlineAnonymousClasses) {
+		this.inlineAnonymousClasses = inlineAnonymousClasses;
 	}
 
-	@Override
 	public boolean isSkipResources() {
-		return isSkipResources;
+		return skipResources;
 	}
 
 	public void setSkipResources(boolean skipResources) {
-		isSkipResources = skipResources;
+		this.skipResources = skipResources;
 	}
 
-	@Override
 	public boolean isSkipSources() {
-		return isSkipSources;
+		return skipSources;
 	}
 
 	public void setSkipSources(boolean skipSources) {
-		isSkipSources = skipSources;
+		this.skipSources = skipSources;
+	}
+
+	public Predicate<String> getClassFilter() {
+		return classFilter;
+	}
+
+	public void setClassFilter(Predicate<String> classFilter) {
+		this.classFilter = classFilter;
 	}
 
-	@Override
 	public boolean isDeobfuscationOn() {
-		return isDeobfuscationOn;
+		return deobfuscationOn;
 	}
 
 	public void setDeobfuscationOn(boolean deobfuscationOn) {
-		isDeobfuscationOn = deobfuscationOn;
+		this.deobfuscationOn = deobfuscationOn;
 	}
 
-	@Override
 	public boolean isDeobfuscationForceSave() {
-		return isDeobfuscationForceSave;
+		return deobfuscationForceSave;
 	}
 
 	public void setDeobfuscationForceSave(boolean deobfuscationForceSave) {
-		isDeobfuscationForceSave = deobfuscationForceSave;
+		this.deobfuscationForceSave = deobfuscationForceSave;
 	}
 
-	@Override
-	public boolean useSourceNameAsClassAlias() {
+	public boolean isUseSourceNameAsClassAlias() {
 		return useSourceNameAsClassAlias;
 	}
 
@@ -136,7 +230,6 @@ public class JadxArgs implements IJadxArgs {
 		this.useSourceNameAsClassAlias = useSourceNameAsClassAlias;
 	}
 
-	@Override
 	public int getDeobfuscationMinLength() {
 		return deobfuscationMinLength;
 	}
@@ -145,7 +238,6 @@ public class JadxArgs implements IJadxArgs {
 		this.deobfuscationMinLength = deobfuscationMinLength;
 	}
 
-	@Override
 	public int getDeobfuscationMaxLength() {
 		return deobfuscationMaxLength;
 	}
@@ -154,8 +246,7 @@ public class JadxArgs implements IJadxArgs {
 		this.deobfuscationMaxLength = deobfuscationMaxLength;
 	}
 
-	@Override
-	public boolean escapeUnicode() {
+	public boolean isEscapeUnicode() {
 		return escapeUnicode;
 	}
 
@@ -163,7 +254,6 @@ public class JadxArgs implements IJadxArgs {
 		this.escapeUnicode = escapeUnicode;
 	}
 
-	@Override
 	public boolean isReplaceConsts() {
 		return replaceConsts;
 	}
@@ -172,7 +262,14 @@ public class JadxArgs implements IJadxArgs {
 		this.replaceConsts = replaceConsts;
 	}
 
-	@Override
+	public boolean isRespectBytecodeAccModifiers() {
+		return respectBytecodeAccModifiers;
+	}
+
+	public void setRespectBytecodeAccModifiers(boolean respectBytecodeAccModifiers) {
+		this.respectBytecodeAccModifiers = respectBytecodeAccModifiers;
+	}
+
 	public boolean isExportAsGradleProject() {
 		return exportAsGradleProject;
 	}
@@ -180,4 +277,94 @@ public class JadxArgs implements IJadxArgs {
 	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 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;
+	}
+
+	@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
+				+ ", deobfuscationForceSave=" + deobfuscationForceSave
+				+ ", useSourceNameAsClassAlias=" + useSourceNameAsClassAlias
+				+ ", deobfuscationMinLength=" + deobfuscationMinLength
+				+ ", deobfuscationMaxLength=" + deobfuscationMaxLength
+				+ ", escapeUnicode=" + escapeUnicode
+				+ ", replaceConsts=" + replaceConsts
+				+ ", respectBytecodeAccModifiers=" + respectBytecodeAccModifiers
+				+ ", exportAsGradleProject=" + exportAsGradleProject
+				+ ", fsCaseSensitive=" + fsCaseSensitive
+				+ ", renameFlags=" + renameFlags
+				+ ", outputFormat=" + outputFormat
+				+ ", codeCache=" + codeCache
+				+ '}';
+	}
 }

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

@@ -0,0 +1,104 @@
+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");
+		}
+		if (inputFiles.size() > 1) {
+			for (File inputFile : inputFiles) {
+				String fileName = inputFile.getName();
+				if (fileName.startsWith("--")) {
+					throw new JadxArgsValidateException("Unknown argument: " + fileName);
+				}
+			}
+			throw new JadxArgsValidateException("Only one input file supported");
+		}
+		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());
+		}
+		if (file.isDirectory()) {
+			throw new JadxArgsValidateException("Expected file but found directory instead: " + 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

@@ -1,129 +1,127 @@
 package jadx.api;
 
-import jadx.core.Jadx;
-import jadx.core.ProcessClass;
-import jadx.core.codegen.CodeGen;
-import jadx.core.dex.attributes.AFlag;
-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.IDexTreeVisitor;
-import jadx.core.dex.visitors.SaveCode;
-import jadx.core.export.ExportGradleProject;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-import jadx.core.utils.files.InputFile;
-import jadx.core.xmlgen.BinaryXMLParser;
-import jadx.core.xmlgen.ResourcesSaver;
-
 import java.io.File;
-import java.io.IOException;
 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 java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
 
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+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.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.InputFile;
+import jadx.core.xmlgen.BinaryXMLParser;
+import jadx.core.xmlgen.ResourcesSaver;
+
 /**
  * Jadx API usage example:
- * <pre><code>
- *  JadxDecompiler jadx = new JadxDecompiler();
- *  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>
+ *
+ * <pre>
+ * <code>
+ * JadxArgs args = new JadxArgs();
+ * args.getInputFiles().add(new File("test.apk"));
+ * args.setOutDir(new File("jadx-test-output"));
+ *
+ * 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>
+ * </code>
+ * </pre>
  */
 public final class JadxDecompiler {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxDecompiler.class);
 
-	private final IJadxArgs args;
-	private final List<InputFile> inputFiles = new ArrayList<InputFile>();
-
-	private File outDir;
+	private JadxArgs args;
+	private List<InputFile> inputFiles;
 
 	private RootNode root;
-	private List<IDexTreeVisitor> passes;
-	private CodeGen codeGen;
-
 	private List<JavaClass> classes;
 	private List<ResourceFile> resources;
 
 	private BinaryXMLParser xmlParser;
 
-	private Map<ClassNode, JavaClass> classesMap = new HashMap<ClassNode, JavaClass>();
-	private Map<MethodNode, JavaMethod> methodsMap = new HashMap<MethodNode, JavaMethod>();
-	private Map<FieldNode, JavaField> fieldsMap = new HashMap<FieldNode, JavaField>();
+	private Map<ClassNode, JavaClass> classesMap = new ConcurrentHashMap<>();
+	private Map<MethodNode, JavaMethod> methodsMap = new ConcurrentHashMap<>();
+	private Map<FieldNode, JavaField> fieldsMap = new ConcurrentHashMap<>();
 
 	public JadxDecompiler() {
 		this(new JadxArgs());
 	}
 
-	public JadxDecompiler(IJadxArgs jadxArgs) {
-		this.args = jadxArgs;
-		this.outDir = jadxArgs.getOutDir();
+	public JadxDecompiler(JadxArgs args) {
+		this.args = args;
+	}
+
+	public void load() {
 		reset();
-		init();
+		JadxArgsValidator.validate(args);
+		LOG.info("loading ...");
+
+		inputFiles = loadFiles(args.getInputFiles());
+
+		root = new RootNode(args);
+		root.load(inputFiles);
+		root.initClassPath();
+		root.loadResources(getResources());
+		root.initPasses();
 	}
 
-	public void setOutputDir(File outDir) {
-		this.outDir = outDir;
-		init();
-	}
-
-	void init() {
-		if (outDir == null) {
-			outDir = new JadxArgs().getOutDir();
-		}
-		this.passes = Jadx.getPassesList(args, outDir);
-		this.codeGen = new CodeGen(args);
-	}
-
-	void reset() {
+	private void reset() {
+		root = null;
 		classes = null;
 		resources = null;
 		xmlParser = null;
-		root = null;
-		passes = null;
-		codeGen = null;
+
+		classesMap.clear();
+		methodsMap.clear();
+		fieldsMap.clear();
 	}
 
 	public static String getVersion() {
 		return Jadx.getVersion();
 	}
 
-	public void loadFile(File file) throws JadxException {
-		loadFiles(Collections.singletonList(file));
-	}
-
-	public void loadFiles(List<File> files) throws JadxException {
+	private List<InputFile> loadFiles(List<File> files) {
 		if (files.isEmpty()) {
-			throw new JadxException("Empty file list");
+			throw new JadxRuntimeException("Empty file list");
 		}
-		inputFiles.clear();
+		List<InputFile> filesList = new ArrayList<>();
 		for (File file : files) {
 			try {
-				InputFile.addFilesFrom(file, inputFiles);
-			} catch (IOException e) {
-				throw new JadxException("Error load file: " + file, e);
+				InputFile.addFilesFrom(file, filesList, args.isSkipSources());
+			} catch (Exception e) {
+				throw new JadxRuntimeException("Error load file: " + file, e);
 			}
 		}
-		parse();
+		return filesList;
 	}
 
 	public void save() {
@@ -139,12 +137,13 @@ public final class JadxDecompiler {
 	}
 
 	private void save(boolean saveSources, boolean saveResources) {
+		ExecutorService ex = getSaveExecutor(saveSources, saveResources);
+		ex.shutdown();
 		try {
-			ExecutorService ex = getSaveExecutor(saveSources, saveResources);
-			ex.shutdown();
 			ex.awaitTermination(1, TimeUnit.DAYS);
 		} catch (InterruptedException e) {
-			throw new JadxRuntimeException("Save interrupted", e);
+			LOG.error("Save interrupted", e);
+			Thread.currentThread().interrupt();
 		}
 	}
 
@@ -165,20 +164,20 @@ public final class JadxDecompiler {
 		File sourcesOutDir;
 		File resOutDir;
 		if (args.isExportAsGradleProject()) {
-			ExportGradleProject export = new ExportGradleProject(root, outDir);
+			ExportGradleProject export = new ExportGradleProject(root, args.getOutDir());
 			export.init();
 			sourcesOutDir = export.getSrcOutDir();
 			resOutDir = export.getResOutDir();
 		} else {
-			sourcesOutDir = outDir;
-			resOutDir = outDir;
-		}
-		if (saveSources) {
-			appendSourcesSave(executor, sourcesOutDir);
+			sourcesOutDir = args.getOutDirSrc();
+			resOutDir = args.getOutDirRes();
 		}
 		if (saveResources) {
 			appendResourcesSave(executor, resOutDir);
 		}
+		if (saveSources) {
+			appendSourcesSave(executor, sourcesOutDir);
+		}
 		return executor;
 	}
 
@@ -188,16 +187,21 @@ public final class JadxDecompiler {
 		}
 	}
 
-	private void appendSourcesSave(ExecutorService executor, final File outDir) {
-		for (final JavaClass cls : getClasses()) {
+	private void appendSourcesSave(ExecutorService executor, File outDir) {
+		final Predicate<String> classFilter = args.getClassFilter();
+		for (JavaClass cls : getClasses()) {
 			if (cls.getClassNode().contains(AFlag.DONT_GENERATE)) {
 				continue;
 			}
-			executor.execute(new Runnable() {
-				@Override
-				public void run() {
-					cls.decompile();
-					SaveCode.save(outDir, args, cls.getClassNode());
+			if (classFilter != null && !classFilter.test(cls.getFullName())) {
+				continue;
+			}
+			executor.execute(() -> {
+				try {
+					ICodeInfo code = cls.getCodeInfo();
+					SaveCode.save(outDir, cls.getClassNode(), code);
+				} catch (Exception e) {
+					LOG.error("Error saving class: {}", cls.getFullName(), e);
 				}
 			});
 		}
@@ -209,12 +213,14 @@ public final class JadxDecompiler {
 		}
 		if (classes == null) {
 			List<ClassNode> classNodeList = root.getClasses(false);
-			List<JavaClass> clsList = new ArrayList<JavaClass>(classNodeList.size());
+			List<JavaClass> clsList = new ArrayList<>(classNodeList.size());
 			classesMap.clear();
 			for (ClassNode classNode : classNodeList) {
-				JavaClass javaClass = new JavaClass(classNode, this);
-				clsList.add(javaClass);
-				classesMap.put(classNode, javaClass);
+				if (!classNode.contains(AFlag.DONT_GENERATE)) {
+					JavaClass javaClass = new JavaClass(classNode, this);
+					clsList.add(javaClass);
+					classesMap.put(classNode, javaClass);
+				}
 			}
 			classes = Collections.unmodifiableList(clsList);
 		}
@@ -236,28 +242,19 @@ public final class JadxDecompiler {
 		if (classList.isEmpty()) {
 			return Collections.emptyList();
 		}
-		Map<String, List<JavaClass>> map = new HashMap<String, List<JavaClass>>();
+		Map<String, List<JavaClass>> map = new HashMap<>();
 		for (JavaClass javaClass : classList) {
 			String pkg = javaClass.getPackage();
-			List<JavaClass> clsList = map.get(pkg);
-			if (clsList == null) {
-				clsList = new ArrayList<JavaClass>();
-				map.put(pkg, clsList);
-			}
+			List<JavaClass> clsList = map.computeIfAbsent(pkg, k -> new ArrayList<>());
 			clsList.add(javaClass);
 		}
-		List<JavaPackage> packages = new ArrayList<JavaPackage>(map.size());
+		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) {
-			Collections.sort(pkg.getClasses(), new Comparator<JavaClass>() {
-				@Override
-				public int compare(JavaClass o1, JavaClass o2) {
-					return o1.getName().compareTo(o2.getName());
-				}
-			});
+			pkg.getClasses().sort(Comparator.comparing(JavaClass::getName, String.CASE_INSENSITIVE_ORDER));
 		}
 		return Collections.unmodifiableList(packages);
 	}
@@ -269,6 +266,13 @@ public final class JadxDecompiler {
 		return root.getErrorsCounter().getErrorCount();
 	}
 
+	public int getWarnsCount() {
+		if (root == null) {
+			return 0;
+		}
+		return root.getErrorsCounter().getWarnsCount();
+	}
+
 	public void printErrorsReport() {
 		if (root == null) {
 			return;
@@ -277,35 +281,6 @@ public final class JadxDecompiler {
 		root.getErrorsCounter().printReport();
 	}
 
-	void parse() throws DecodeException {
-		reset();
-		init();
-
-		root = new RootNode(args);
-		LOG.info("loading ...");
-		root.load(inputFiles);
-
-		root.initClassPath();
-		root.loadResources(getResources());
-		root.initAppResClass();
-
-		initVisitors();
-	}
-
-	private void initVisitors() {
-		for (IDexTreeVisitor pass : passes) {
-			try {
-				pass.init(root);
-			} catch (Exception e) {
-				LOG.error("Visitor init failed: {}", pass.getClass().getSimpleName(), e);
-			}
-		}
-	}
-
-	void processClass(ClassNode cls) {
-		ProcessClass.process(cls, passes, codeGen);
-	}
-
 	RootNode getRoot() {
 		return root;
 	}
@@ -317,19 +292,136 @@ public final class JadxDecompiler {
 		return xmlParser;
 	}
 
-	Map<ClassNode, JavaClass> getClassesMap() {
-		return classesMap;
+	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);
+		}
 	}
 
-	Map<MethodNode, JavaMethod> getMethodsMap() {
-		return methodsMap;
+	@Nullable("For not generated classes")
+	private JavaClass getJavaClassByNode(ClassNode cls) {
+		JavaClass javaClass = classesMap.get(cls);
+		if (javaClass != null) {
+			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);
 	}
 
-	Map<FieldNode, JavaField> getFieldsMap() {
-		return fieldsMap;
+	@Nullable
+	private JavaMethod getJavaMethodByNode(MethodNode mth) {
+		JavaMethod javaMethod = methodsMap.get(mth);
+		if (javaMethod != null) {
+			return javaMethod;
+		}
+		// 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);
 	}
 
-	public IJadxArgs getArgs() {
+	@Nullable
+	private JavaField getJavaFieldByNode(FieldNode fld) {
+		JavaField javaField = fieldsMap.get(fld);
+		if (javaField != null) {
+			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
+	JavaNode convertNode(Object obj) {
+		if (!(obj instanceof LineAttrNode)) {
+			return null;
+		}
+		LineAttrNode node = (LineAttrNode) obj;
+		if (node.contains(AFlag.DONT_GENERATE)) {
+			return null;
+		}
+		if (obj instanceof ClassNode) {
+			return getJavaClassByNode((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);
+	}
+
+	@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(jCls, defLine, 0);
+	}
+
+	public JadxArgs getArgs() {
 		return args;
 	}
 
@@ -337,5 +429,4 @@ public final class JadxDecompiler {
 	public String toString() {
 		return "jadx decompiler " + getVersion();
 	}
-
 }

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

@@ -1,13 +1,5 @@
 package jadx.api;
 
-import jadx.core.codegen.CodeWriter;
-import jadx.core.dex.attributes.AFlag;
-import jadx.core.dex.attributes.nodes.LineAttrNode;
-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;
@@ -17,6 +9,12 @@ import java.util.Map;
 
 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;
+
 public final class JavaClass implements JavaNode {
 
 	private final JadxDecompiler decompiler;
@@ -26,6 +24,7 @@ public final class JavaClass implements JavaNode {
 	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;
@@ -43,42 +42,49 @@ public final class JavaClass implements JavaNode {
 	}
 
 	public String getCode() {
-		CodeWriter code = cls.getCode();
+		ICodeInfo code = getCodeInfo();
 		if (code == null) {
-			decompile();
-			code = cls.getCode();
-			if (code == null) {
-				return "";
-			}
+			return "";
 		}
 		return code.getCodeStr();
 	}
 
-	public synchronized void decompile() {
-		if (decompiler == null) {
-			return;
-		}
-		if (cls.getCode() == null) {
-			decompiler.processClass(cls);
-			load();
-		}
+	public ICodeInfo getCodeInfo() {
+		return cls.decompile();
 	}
 
-	ClassNode getClassNode() {
+	public void decompile() {
+		cls.decompile();
+	}
+
+	public synchronized String getSmali() {
+		return cls.getSmali();
+	}
+
+	public synchronized void unload() {
+		cls.unload();
+		listsLoaded = false;
+	}
+
+	public ClassNode getClassNode() {
 		return cls;
 	}
 
-	private void load() {
-		JadxDecompiler rootDecompiler = getRootDecompiler();
+	private void loadLists() {
+		if (listsLoaded) {
+			return;
+		}
+		listsLoaded = true;
+		decompile();
+
 		int inClsCount = cls.getInnerClasses().size();
 		if (inClsCount != 0) {
-			List<JavaClass> list = new ArrayList<JavaClass>(inClsCount);
+			List<JavaClass> list = new ArrayList<>(inClsCount);
 			for (ClassNode inner : cls.getInnerClasses()) {
 				if (!inner.contains(AFlag.DONT_GENERATE)) {
 					JavaClass javaClass = new JavaClass(inner, this);
-					javaClass.load();
+					javaClass.loadLists();
 					list.add(javaClass);
-					rootDecompiler.getClassesMap().put(inner, javaClass);
 				}
 			}
 			this.innerClasses = Collections.unmodifiableList(list);
@@ -86,12 +92,11 @@ public final class JavaClass implements JavaNode {
 
 		int fieldsCount = cls.getFields().size();
 		if (fieldsCount != 0) {
-			List<JavaField> flds = new ArrayList<JavaField>(fieldsCount);
+			List<JavaField> flds = new ArrayList<>(fieldsCount);
 			for (FieldNode f : cls.getFields()) {
 				if (!f.contains(AFlag.DONT_GENERATE)) {
 					JavaField javaField = new JavaField(f, this);
 					flds.add(javaField);
-					rootDecompiler.getFieldsMap().put(f, javaField);
 				}
 			}
 			this.fields = Collections.unmodifiableList(flds);
@@ -99,20 +104,14 @@ public final class JavaClass implements JavaNode {
 
 		int methodsCount = cls.getMethods().size();
 		if (methodsCount != 0) {
-			List<JavaMethod> mths = new ArrayList<JavaMethod>(methodsCount);
+			List<JavaMethod> mths = new ArrayList<>(methodsCount);
 			for (MethodNode m : cls.getMethods()) {
 				if (!m.contains(AFlag.DONT_GENERATE)) {
 					JavaMethod javaMethod = new JavaMethod(this, m);
 					mths.add(javaMethod);
-					rootDecompiler.getMethodsMap().put(m, 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);
 		}
 	}
@@ -125,8 +124,11 @@ public final class JavaClass implements JavaNode {
 	}
 
 	private Map<CodePosition, Object> getCodeAnnotations() {
-		decompile();
-		return cls.getCode().getAnnotations();
+		ICodeInfo code = getCodeInfo();
+		if (code == null) {
+			return Collections.emptyMap();
+		}
+		return code.getAnnotations();
 	}
 
 	public Map<CodePosition, JavaNode> getUsageMap() {
@@ -134,73 +136,32 @@ public final class JavaClass implements JavaNode {
 		if (map.isEmpty() || decompiler == null) {
 			return Collections.emptyMap();
 		}
-		Map<CodePosition, JavaNode> resultMap = new HashMap<CodePosition, JavaNode>(map.size());
+		Map<CodePosition, JavaNode> resultMap = new HashMap<>(map.size());
 		for (Map.Entry<CodePosition, Object> entry : map.entrySet()) {
 			CodePosition codePosition = entry.getKey();
 			Object obj = entry.getValue();
-			if (obj instanceof LineAttrNode) {
-				JavaNode node = convertNode(obj);
-				if (node != null) {
-					resultMap.put(codePosition, node);
-				}
+			JavaNode node = getRootDecompiler().convertNode(obj);
+			if (node != null) {
+				resultMap.put(codePosition, node);
 			}
 		}
 		return resultMap;
 	}
 
 	@Nullable
-	private JavaNode convertNode(Object obj) {
-		if (!(obj instanceof LineAttrNode)) {
-			return null;
-		}
-		if (obj instanceof ClassNode) {
-			return getRootDecompiler().getClassesMap().get(obj);
-		}
-		if (obj instanceof MethodNode) {
-			return getRootDecompiler().getMethodsMap().get(obj);
-		}
-		if (obj instanceof FieldNode) {
-			return getRootDecompiler().getFieldsMap().get(obj);
-		}
-		return null;
-	}
-
-	@Nullable
+	@Deprecated
 	public JavaNode getJavaNodeAtPosition(int line, int offset) {
-		Map<CodePosition, Object> map = getCodeAnnotations();
-		if (map.isEmpty()) {
-			return null;
-		}
-		Object obj = map.get(new CodePosition(line, offset));
-		if (obj == null) {
-			return null;
-		}
-		return convertNode(obj);
+		return getRootDecompiler().getJavaNodeAtPosition(getCodeInfo(), line, offset);
 	}
 
 	@Nullable
-	public CodePosition getDefinitionPosition(int line, int offset) {
-		JavaNode javaNode = getJavaNodeAtPosition(line, offset);
-		if (javaNode == null) {
-			return null;
-		}
-		return getDefinitionPosition(javaNode);
-	}
-
-	@Nullable
-	public CodePosition getDefinitionPosition(JavaNode javaNode) {
-		JavaClass jCls = javaNode.getTopParentClass();
-		jCls.decompile();
-		int defLine = javaNode.getDecompiledLine();
-		if (defLine == 0) {
-			return null;
-		}
-		return new CodePosition(jCls, defLine, 0);
+	@Deprecated
+	public CodePosition getDefinitionPosition() {
+		return getRootDecompiler().getDefinitionPosition(this);
 	}
 
 	public Integer getSourceLine(int decompiledLine) {
-		decompile();
-		return cls.getCode().getLineMapping().get(decompiledLine);
+		return getCodeInfo().getLineMapping().get(decompiledLine);
 	}
 
 	@Override
@@ -232,20 +193,21 @@ public final class JavaClass implements JavaNode {
 	}
 
 	public List<JavaClass> getInnerClasses() {
-		decompile();
+		loadLists();
 		return innerClasses;
 	}
 
 	public List<JavaField> getFields() {
-		decompile();
+		loadLists();
 		return fields;
 	}
 
 	public List<JavaMethod> getMethods() {
-		decompile();
+		loadLists();
 		return methods;
 	}
 
+	@Override
 	public int getDecompiledLine() {
 		return cls.getDecompiledLine();
 	}
@@ -262,6 +224,6 @@ public final class JavaClass implements JavaNode {
 
 	@Override
 	public String toString() {
-		return cls.getFullName() + "[ " + getFullName() + " ]";
+		return getFullName();
 	}
 }

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

@@ -21,7 +21,7 @@ public final class JavaField implements JavaNode {
 
 	@Override
 	public String getFullName() {
-		return parent.getFullName() + "." + getName();
+		return parent.getFullName() + '.' + getName();
 	}
 
 	@Override
@@ -39,13 +39,17 @@ public final class JavaField implements JavaNode {
 	}
 
 	public ArgType getType() {
-		return field.getType();
+		return ArgType.tryToResolveClassAlias(field.dex(), field.getType());
 	}
 
 	public int getDecompiledLine() {
 		return field.getDecompiledLine();
 	}
 
+	FieldNode getFieldNode() {
+		return field;
+	}
+
 	@Override
 	public int hashCode() {
 		return field.hashCode();

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

@@ -1,10 +1,12 @@
 package jadx.api;
 
+import java.util.Collections;
+import java.util.List;
+
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.MethodNode;
-
-import java.util.List;
+import jadx.core.utils.Utils;
 
 public final class JavaMethod implements JavaNode {
 	private final MethodNode mth;
@@ -40,11 +42,24 @@ public final class JavaMethod implements JavaNode {
 	}
 
 	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();
+		if (arguments == null) {
+			arguments = infoArgTypes;
+		}
+		return Utils.collectionMap(arguments,
+				type -> ArgType.tryToResolveClassAlias(mth.dex(), type));
 	}
 
 	public ArgType getReturnType() {
-		return mth.getReturnType();
+		ArgType retType = mth.getReturnType();
+		if (retType == null) {
+			retType = mth.getMethodInfo().getReturnType();
+		}
+		return ArgType.tryToResolveClassAlias(mth.dex(), retType);
 	}
 
 	public boolean isConstructor() {
@@ -59,6 +74,10 @@ public final class JavaMethod implements JavaNode {
 		return mth.getDecompiledLine();
 	}
 
+	MethodNode getMethodNode() {
+		return mth;
+	}
+
 	@Override
 	public int hashCode() {
 		return mth.hashCode();

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

@@ -1,9 +1,10 @@
 package jadx.api;
 
-import jadx.core.xmlgen.ResContainer;
-
 import java.io.File;
 
+import jadx.core.utils.files.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+
 public class ResourceFile {
 
 	public static final class ZipRef {
@@ -34,7 +35,14 @@ public class ResourceFile {
 	private final ResourceType type;
 	private ZipRef zipRef;
 
-	ResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+	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;
@@ -56,12 +64,12 @@ public class ResourceFile {
 		this.zipRef = zipRef;
 	}
 
-	ZipRef getZipRef() {
+	public ZipRef getZipRef() {
 		return zipRef;
 	}
 
 	@Override
 	public String toString() {
-		return "ResourceFile{name='" + name + '\'' + ", type=" + type + "}";
+		return "ResourceFile{name='" + name + '\'' + ", type=" + type + '}';
 	}
 }

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

@@ -4,7 +4,6 @@ import jadx.core.codegen.CodeWriter;
 import jadx.core.xmlgen.ResContainer;
 
 public class ResourceFileContent extends ResourceFile {
-
 	private final CodeWriter content;
 
 	public ResourceFileContent(String name, ResourceType type, CodeWriter content) {
@@ -14,6 +13,6 @@ public class ResourceFileContent extends ResourceFile {
 
 	@Override
 	public ResContainer loadContent() {
-		return ResContainer.singleFile(getName(), content);
+		return ResContainer.textResource(getName(), content);
 	}
 }

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

@@ -5,8 +5,9 @@ public enum ResourceType {
 	MANIFEST("AndroidManifest.xml"),
 	XML(".xml"),
 	ARSC(".arsc"),
-	FONT(".ttf"),
+	FONT(".ttf", ".otf"),
 	IMG(".png", ".gif", ".jpg"),
+	MEDIA(".mp3", ".wav"),
 	LIB(".so"),
 	UNKNOWN;
 
@@ -23,28 +24,11 @@ public enum ResourceType {
 	public static ResourceType getFileType(String fileName) {
 		for (ResourceType type : ResourceType.values()) {
 			for (String ext : type.getExts()) {
-				if (fileName.endsWith(ext)) {
+				if (fileName.toLowerCase().endsWith(ext)) {
 					return type;
 				}
 			}
 		}
 		return UNKNOWN;
 	}
-
-	public static boolean isSupportedForUnpack(ResourceType type) {
-		switch (type) {
-			case CODE:
-			case LIB:
-			case FONT:
-			case UNKNOWN:
-				return false;
-
-			case MANIFEST:
-			case XML:
-			case ARSC:
-			case IMG:
-				return true;
-		}
-		return false;
-	}
 }

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

@@ -1,16 +1,9 @@
 package jadx.api;
 
-import jadx.api.ResourceFile.ZipRef;
-import jadx.core.codegen.CodeWriter;
-import jadx.core.utils.Utils;
-import jadx.core.utils.exceptions.JadxException;
-import jadx.core.utils.files.InputFile;
-import jadx.core.xmlgen.ResContainer;
-import jadx.core.xmlgen.ResTableParser;
-
 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;
@@ -22,16 +15,23 @@ import java.util.zip.ZipFile;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.ResourceFile.ZipRef;
+import jadx.core.codegen.CodeWriter;
+import jadx.core.utils.Utils;
+import jadx.core.utils.android.Res9patchStreamDecoder;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.files.InputFile;
+import jadx.core.utils.files.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.ResTableParser;
+
 import static jadx.core.utils.files.FileUtils.READ_BUFFER_SIZE;
-import static jadx.core.utils.files.FileUtils.close;
 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 static final int LOAD_SIZE_LIMIT = 10 * 1024 * 1024;
-
 	private final JadxDecompiler jadxRef;
 
 	ResourcesLoader(JadxDecompiler jadxRef) {
@@ -39,108 +39,113 @@ public final class ResourcesLoader {
 	}
 
 	List<ResourceFile> load(List<InputFile> inputFiles) {
-		List<ResourceFile> list = new ArrayList<ResourceFile>(inputFiles.size());
+		List<ResourceFile> list = new ArrayList<>(inputFiles.size());
 		for (InputFile file : inputFiles) {
 			loadFile(list, file.getFile());
 		}
 		return list;
 	}
 
-	public interface ResourceDecoder {
-		ResContainer decode(long size, InputStream is) throws IOException;
+	public interface ResourceDecoder<T> {
+		T decode(long size, InputStream is) throws IOException;
 	}
 
-	public static ResContainer decodeStream(ResourceFile rf, ResourceDecoder decoder) throws JadxException {
-		ZipRef zipRef = rf.getZipRef();
-		if (zipRef == null) {
-			return null;
-		}
-		ZipFile zipFile = null;
-		InputStream inputStream = null;
-		ResContainer result = null;
+	public static <T> T decodeStream(ResourceFile rf, ResourceDecoder<T> decoder) throws JadxException {
 		try {
-			zipFile = new ZipFile(zipRef.getZipFile());
-			ZipEntry entry = zipFile.getEntry(zipRef.getEntryName());
-			if (entry == null) {
-				throw new IOException("Zip entry not found: " + zipRef);
+			ZipRef zipRef = rf.getZipRef();
+			if (zipRef == null) {
+				File file = new File(rf.getName());
+				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 = new BufferedInputStream(zipFile.getInputStream(entry))) {
+						return decoder.decode(entry.getSize(), inputStream);
+					}
+				}
 			}
-			inputStream = new BufferedInputStream(zipFile.getInputStream(entry));
-			result = decoder.decode(entry.getSize(), inputStream);
 		} catch (Exception e) {
-			throw new JadxException("Error decode: " + zipRef.getEntryName(), e);
-		} finally {
-			try {
-				if (zipFile != null) {
-					zipFile.close();
-				}
-			} catch (Exception e) {
-				LOG.error("Error close zip file: {}", zipRef, e);
-			}
-			close(inputStream);
+			throw new JadxException("Error decode: " + rf.getName(), e);
 		}
-		return result;
 	}
 
-	static ResContainer loadContent(final JadxDecompiler jadxRef, final ResourceFile rf) {
+	static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf) {
 		try {
-			return decodeStream(rf, new ResourceDecoder() {
-				@Override
-				public ResContainer decode(long size, InputStream is) throws IOException {
-					return loadContent(jadxRef, rf, is, size);
-				}
-			});
+			return decodeStream(rf, (size, is) -> loadContent(jadxRef, rf, is));
 		} catch (JadxException e) {
 			LOG.error("Decode error", e);
 			CodeWriter cw = new CodeWriter();
 			cw.add("Error decode ").add(rf.getType().toString().toLowerCase());
-			cw.startLine(Utils.getStackTrace(e.getCause()));
-			return ResContainer.singleFile(rf.getName(), cw);
+			Utils.appendStackTrace(cw, e.getCause());
+			return ResContainer.textResource(rf.getName(), cw);
 		}
 	}
 
 	private static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf,
-			InputStream inputStream, long size) throws IOException {
+			InputStream inputStream) throws IOException {
 		switch (rf.getType()) {
 			case MANIFEST:
 			case XML:
-				return ResContainer.singleFile(rf.getName(),
-						jadxRef.getXmlParser().parse(inputStream));
+				CodeWriter content = jadxRef.getXmlParser().parse(inputStream);
+				return ResContainer.textResource(rf.getName(), content);
 
 			case ARSC:
-				return new ResTableParser().decodeFiles(inputStream);
+				return new ResTableParser(jadxRef.getRoot()).decodeFiles(inputStream);
 
 			case IMG:
-				return ResContainer.singleImageFile(rf.getName(), inputStream);
+				return decodeImage(rf, inputStream);
+
+			default:
+				return ResContainer.resourceFileLink(rf);
 		}
-		if (size > LOAD_SIZE_LIMIT) {
-			return ResContainer.singleFile(rf.getName(),
-					new CodeWriter().add("File too big, size: " + String.format("%.2f KB", size / 1024.)));
+	}
+
+	private static ResContainer decodeImage(ResourceFile rf, InputStream inputStream) {
+		String name = rf.getName();
+		if (name.endsWith(".9.png")) {
+			try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
+				Res9patchStreamDecoder decoder = new Res9patchStreamDecoder();
+				decoder.decode(inputStream, os);
+				return ResContainer.decodedData(rf.getName(), os.toByteArray());
+			} catch (Exception e) {
+				LOG.error("Failed to decode 9-patch png image, path: {}", name, e);
+			}
 		}
-		return ResContainer.singleFile(rf.getName(), loadToCodeWriter(inputStream));
+		return ResContainer.resourceFileLink(rf);
 	}
 
 	private void loadFile(List<ResourceFile> list, File file) {
 		if (file == null) {
 			return;
 		}
-		ZipFile zip = null;
-		try {
-			zip = new ZipFile(file);
+		try (ZipFile zip = new ZipFile(file)) {
 			Enumeration<? extends ZipEntry> entries = zip.entries();
 			while (entries.hasMoreElements()) {
 				ZipEntry entry = entries.nextElement();
-				addEntry(list, file, entry);
-			}
-		} catch (IOException e) {
-			LOG.debug("Not a zip file: {}", file.getAbsolutePath());
-		} finally {
-			if (zip != null) {
-				try {
-					zip.close();
-				} catch (Exception e) {
-					LOG.error("Zip file close error: {}", file.getAbsolutePath(), e);
+				if (ZipSecurity.isValidZipEntry(entry)) {
+					addEntry(list, file, entry);
 				}
 			}
+		} catch (Exception e) {
+			LOG.debug("Not a zip file: {}", file.getAbsolutePath());
+			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);
 		}
 	}
 
@@ -150,16 +155,16 @@ public final class ResourcesLoader {
 		}
 		String name = entry.getName();
 		ResourceType type = ResourceType.getFileType(name);
-		ResourceFile rf = new ResourceFile(jadxRef, name, type);
-		rf.setZipRef(new ZipRef(zipFile, name));
-		list.add(rf);
+		ResourceFile rf = ResourceFile.createResourceFile(jadxRef, name, type);
+		if (rf != null) {
+			rf.setZipRef(new ZipRef(zipFile, name));
+			list.add(rf);
+		}
 	}
 
 	public static CodeWriter loadToCodeWriter(InputStream is) throws IOException {
-		CodeWriter cw = new CodeWriter();
 		ByteArrayOutputStream baos = new ByteArrayOutputStream(READ_BUFFER_SIZE);
 		copyStream(is, baos);
-		cw.add(baos.toString("UTF-8"));
-		return cw;
+		return new CodeWriter(baos.toString("UTF-8"));
 	}
 }

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

@@ -0,0 +1,24 @@
+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 @Nullable ICodeInfo get(String clsFullName) {
+		return storage.get(clsFullName);
+	}
+}

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

@@ -0,0 +1,19 @@
+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 @Nullable ICodeInfo get(String clsFullName) {
+		return null;
+	}
+}

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

@@ -21,4 +21,7 @@ public class Consts {
 	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,39 +1,6 @@
 package jadx.core;
 
-import jadx.api.IJadxArgs;
-import jadx.core.dex.visitors.ClassModifier;
-import jadx.core.dex.visitors.CodeShrinker;
-import jadx.core.dex.visitors.ConstInlineVisitor;
-import jadx.core.dex.visitors.DebugInfoVisitor;
-import jadx.core.dex.visitors.DependencyCollector;
-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.IDexTreeVisitor;
-import jadx.core.dex.visitors.MethodInlineVisitor;
-import jadx.core.dex.visitors.ModVisitor;
-import jadx.core.dex.visitors.PrepareForCodeGen;
-import jadx.core.dex.visitors.ReSugarCode;
-import jadx.core.dex.visitors.RenameVisitor;
-import jadx.core.dex.visitors.SimplifyVisitor;
-import jadx.core.dex.visitors.blocksmaker.BlockExceptionHandler;
-import jadx.core.dex.visitors.blocksmaker.BlockFinallyExtract;
-import jadx.core.dex.visitors.blocksmaker.BlockFinish;
-import jadx.core.dex.visitors.blocksmaker.BlockProcessor;
-import jadx.core.dex.visitors.blocksmaker.BlockSplitter;
-import jadx.core.dex.visitors.regions.CheckRegions;
-import jadx.core.dex.visitors.regions.IfRegionVisitor;
-import jadx.core.dex.visitors.regions.LoopRegionVisitor;
-import jadx.core.dex.visitors.regions.ProcessVariables;
-import jadx.core.dex.visitors.regions.RegionMakerVisitor;
-import jadx.core.dex.visitors.regions.ReturnVisitor;
-import jadx.core.dex.visitors.ssa.EliminatePhiNodes;
-import jadx.core.dex.visitors.ssa.SSATransform;
-import jadx.core.dex.visitors.typeinference.FinishTypeInference;
-import jadx.core.dex.visitors.typeinference.TypeInference;
-
-import java.io.File;
+import java.io.InputStream;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Enumeration;
@@ -43,69 +10,116 @@ import java.util.jar.Manifest;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.JadxArgs;
+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.DependencyCollector;
+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.IDexTreeVisitor;
+import jadx.core.dex.visitors.InitCodeVariables;
+import jadx.core.dex.visitors.MarkFinallyVisitor;
+import jadx.core.dex.visitors.MethodInlineVisitor;
+import jadx.core.dex.visitors.ModVisitor;
+import jadx.core.dex.visitors.PrepareForCodeGen;
+import jadx.core.dex.visitors.ProcessAnonymous;
+import jadx.core.dex.visitors.ReSugarCode;
+import jadx.core.dex.visitors.RenameVisitor;
+import jadx.core.dex.visitors.SimplifyVisitor;
+import jadx.core.dex.visitors.blocksmaker.BlockExceptionHandler;
+import jadx.core.dex.visitors.blocksmaker.BlockFinish;
+import jadx.core.dex.visitors.blocksmaker.BlockProcessor;
+import jadx.core.dex.visitors.blocksmaker.BlockSplitter;
+import jadx.core.dex.visitors.debuginfo.DebugInfoApplyVisitor;
+import jadx.core.dex.visitors.debuginfo.DebugInfoParseVisitor;
+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.shrink.CodeShrinkVisitor;
+import jadx.core.dex.visitors.ssa.SSATransform;
+import jadx.core.dex.visitors.typeinference.TypeInferenceVisitor;
+
 public class Jadx {
 	private static final Logger LOG = LoggerFactory.getLogger(Jadx.class);
 
+	private Jadx() {
+	}
+
 	static {
 		if (Consts.DEBUG) {
 			LOG.info("debug enabled");
 		}
 	}
 
-	public static List<IDexTreeVisitor> getPassesList(IJadxArgs args, File outDir) {
-		List<IDexTreeVisitor> passes = new ArrayList<IDexTreeVisitor>();
+	public static List<IDexTreeVisitor> getPassesList(JadxArgs args) {
+		List<IDexTreeVisitor> passes = new ArrayList<>();
 		if (args.isFallbackMode()) {
 			passes.add(new FallbackModeVisitor());
 		} else {
+			if (args.isDebugInfo()) {
+				passes.add(new DebugInfoParseVisitor());
+			}
+
 			passes.add(new BlockSplitter());
+			if (args.isRawCFGOutput()) {
+				passes.add(DotGraphVisitor.dumpRaw());
+			}
+
 			passes.add(new BlockProcessor());
 			passes.add(new BlockExceptionHandler());
-			passes.add(new BlockFinallyExtract());
 			passes.add(new BlockFinish());
 
 			passes.add(new SSATransform());
-			passes.add(new DebugInfoVisitor());
-			passes.add(new TypeInference());
-
-			if (args.isRawCFGOutput()) {
-				passes.add(DotGraphVisitor.dumpRaw(outDir));
+			passes.add(new ConstructorVisitor());
+			passes.add(new InitCodeVariables());
+			passes.add(new MarkFinallyVisitor());
+			passes.add(new ConstInlineVisitor());
+			passes.add(new TypeInferenceVisitor());
+			if (args.isDebugInfo()) {
+				passes.add(new DebugInfoApplyVisitor());
 			}
 
-			passes.add(new ConstInlineVisitor());
-			passes.add(new FinishTypeInference());
-			passes.add(new EliminatePhiNodes());
-
+			passes.add(new DeboxingVisitor());
 			passes.add(new ModVisitor());
-
-			passes.add(new CodeShrinker());
+			passes.add(new CodeShrinkVisitor());
 			passes.add(new ReSugarCode());
-
-			if (args.isCFGOutput()) {
-				passes.add(DotGraphVisitor.dump(outDir));
+			if (args.isCfgOutput()) {
+				passes.add(DotGraphVisitor.dump());
 			}
 
 			passes.add(new RegionMakerVisitor());
 			passes.add(new IfRegionVisitor());
 			passes.add(new ReturnVisitor());
+			passes.add(new CleanRegions());
 
-			passes.add(new CodeShrinker());
+			passes.add(new CodeShrinkVisitor());
 			passes.add(new SimplifyVisitor());
 			passes.add(new CheckRegions());
 
-			if (args.isCFGOutput()) {
-				passes.add(DotGraphVisitor.dumpRegions(outDir));
+			passes.add(new ExtractFieldInit());
+			passes.add(new FixAccessModifiers());
+			passes.add(new ProcessAnonymous());
+			passes.add(new ClassModifier());
+			passes.add(new MethodInlineVisitor());
+			passes.add(new EnumVisitor());
+			passes.add(new LoopRegionVisitor());
+
+			passes.add(new ProcessVariables());
+			passes.add(new PrepareForCodeGen());
+			if (args.isCfgOutput()) {
+				passes.add(DotGraphVisitor.dumpRegions());
 			}
 
-			passes.add(new MethodInlineVisitor());
-			passes.add(new ExtractFieldInit());
-			passes.add(new ClassModifier());
-			passes.add(new EnumVisitor());
-			passes.add(new PrepareForCodeGen());
-			passes.add(new LoopRegionVisitor());
-			passes.add(new ProcessVariables());
-
 			passes.add(new DependencyCollector());
-
 			passes.add(new RenameVisitor());
 		}
 		return passes;
@@ -117,10 +131,12 @@ public class Jadx {
 			if (classLoader != null) {
 				Enumeration<URL> resources = classLoader.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;
+					try (InputStream is = resources.nextElement().openStream()) {
+						Manifest manifest = new Manifest(is);
+						String ver = manifest.getMainAttributes().getValue("jadx-version");
+						if (ver != null) {
+							return ver;
+						}
 					}
 				}
 			}

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

@@ -1,62 +1,68 @@
 package jadx.core;
 
+import org.jetbrains.annotations.NotNull;
+
+import jadx.api.ICodeInfo;
 import jadx.core.codegen.CodeGen;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.visitors.DepthTraversal;
 import jadx.core.dex.visitors.IDexTreeVisitor;
 import jadx.core.utils.ErrorsCounter;
+import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import java.util.List;
-
-import org.jetbrains.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static jadx.core.dex.nodes.ProcessState.GENERATED;
+import static jadx.core.dex.nodes.ProcessState.LOADED;
 import static jadx.core.dex.nodes.ProcessState.NOT_LOADED;
-import static jadx.core.dex.nodes.ProcessState.PROCESSED;
-import static jadx.core.dex.nodes.ProcessState.STARTED;
-import static jadx.core.dex.nodes.ProcessState.UNLOADED;
+import static jadx.core.dex.nodes.ProcessState.PROCESS_COMPLETE;
+import static jadx.core.dex.nodes.ProcessState.PROCESS_STARTED;
 
 public final class ProcessClass {
-	private static final Logger LOG = LoggerFactory.getLogger(ProcessClass.class);
 
 	private ProcessClass() {
 	}
 
-	public static void process(ClassNode cls, List<IDexTreeVisitor> passes, @Nullable CodeGen codeGen) {
-		if (codeGen == null && cls.getState() == PROCESSED) {
+	public static void process(ClassNode cls) {
+		ClassNode topParentClass = cls.getTopParentClass();
+		if (topParentClass != cls) {
+			process(topParentClass);
 			return;
 		}
-		synchronized (cls) {
+		if (cls.getState().isProcessed()) {
+			// nothing to do
+			return;
+		}
+		synchronized (cls.getClassInfo()) {
 			try {
 				if (cls.getState() == NOT_LOADED) {
 					cls.load();
-					cls.setState(STARTED);
-					for (IDexTreeVisitor visitor : passes) {
+				}
+				if (cls.getState() == LOADED) {
+					cls.setState(PROCESS_STARTED);
+					for (IDexTreeVisitor visitor : cls.root().getPasses()) {
 						DepthTraversal.visit(visitor, cls);
 					}
-					cls.setState(PROCESSED);
+					cls.setState(PROCESS_COMPLETE);
 				}
-				if (cls.getState() == PROCESSED && codeGen != null) {
-					processDependencies(cls, passes);
-					codeGen.visit(cls);
-					cls.setState(GENERATED);
-				}
-			} catch (Exception e) {
+			} catch (Throwable e) {
 				ErrorsCounter.classError(cls, e.getClass().getSimpleName(), e);
-			} finally {
-				if (cls.getState() == GENERATED) {
-					cls.unload();
-					cls.setState(UNLOADED);
-				}
 			}
 		}
 	}
 
-	static void processDependencies(ClassNode cls, List<IDexTreeVisitor> passes) {
-		for (ClassNode depCls : cls.getDependencies()) {
-			process(depCls, passes, null);
+	@NotNull
+	public static ICodeInfo generateCode(ClassNode cls) {
+		ClassNode topParentClass = cls.getTopParentClass();
+		if (topParentClass != cls) {
+			return generateCode(topParentClass);
+		}
+		try {
+			process(cls);
+			cls.getDependencies().forEach(ProcessClass::process);
+
+			ICodeInfo code = CodeGen.generate(cls);
+			cls.unload();
+			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,22 +1,18 @@
 package jadx.core.clsp;
 
-import jadx.core.dex.instructions.args.ArgType;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.RootNode;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-import jadx.core.utils.files.FileUtils;
-
 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;
@@ -27,7 +23,16 @@ import java.util.zip.ZipOutputStream;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static jadx.core.utils.files.FileUtils.close;
+import jadx.core.dex.info.AccessInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.GenericInfo;
+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;
+import jadx.core.utils.files.ZipSecurity;
 
 /**
  * Classes list for import into classpath graph
@@ -40,24 +45,42 @@ public class ClsSet {
 	private static final String CLST_PKG_PATH = ClsSet.class.getPackage().getName().replace('.', '/');
 
 	private static final String JADX_CLS_SET_HEADER = "jadx-cst";
-	private static final int VERSION = 1;
+	private static final int VERSION = 2;
 
 	private static final String STRING_CHARSET = "US-ASCII";
 
+	private static final NClass[] EMPTY_NCLASS_ARRAY = new NClass[0];
+
+	private enum TypeEnum {
+		WILDCARD, GENERIC, GENERIC_TYPE, OBJECT, ARRAY, PRIMITIVE
+	}
+
 	private NClass[] classes;
 
-	public void load(RootNode root) {
+	public void loadFromClstFile() throws IOException, DecodeException {
+		try (InputStream input = getClass().getResourceAsStream(CLST_FILENAME)) {
+			if (input == null) {
+				throw new JadxRuntimeException("Can't load classpath file: " + CLST_FILENAME);
+			}
+			load(input);
+		}
+	}
+
+	public void loadFrom(RootNode root) {
 		List<ClassNode> list = root.getClasses(true);
-		Map<String, NClass> names = new HashMap<String, NClass>(list.size());
+		Map<String, NClass> names = new HashMap<>(list.size());
 		int k = 0;
 		for (ClassNode cls : list) {
 			String clsRawName = cls.getRawName();
 			if (cls.getAccessFlags().isPublic()) {
+				cls.load();
 				NClass nClass = new NClass(clsRawName, k);
 				if (names.put(clsRawName, nClass) != null) {
 					throw new JadxRuntimeException("Duplicate class: " + clsRawName);
 				}
 				k++;
+				nClass.setGenerics(cls.getGenerics());
+				nClass.setMethods(getMethodsDetails(cls));
 			} else {
 				names.put(clsRawName, null);
 			}
@@ -77,8 +100,46 @@ public class ClsSet {
 		}
 	}
 
+	private List<NMethod> getMethodsDetails(ClassNode cls) {
+		List<NMethod> methods = new ArrayList<>();
+		for (MethodNode m : cls.getMethods()) {
+			AccessInfo accessFlags = m.getAccessFlags();
+			if (accessFlags.isPublic() || accessFlags.isProtected()) {
+				processMethodDetails(methods, m, accessFlags);
+			}
+		}
+		return methods;
+	}
+
+	private void processMethodDetails(List<NMethod> methods, MethodNode mth, AccessInfo accessFlags) {
+		List<ArgType> args = mth.getArgTypes();
+		boolean genericArg = false;
+		ArgType[] genericArgs;
+		if (args.isEmpty()) {
+			genericArgs = null;
+		} else {
+			int argsCount = args.size();
+			genericArgs = new ArgType[argsCount];
+			for (int i = 0; i < argsCount; i++) {
+				ArgType argType = args.get(i);
+				if (argType.isGeneric() || argType.isGenericType()) {
+					genericArgs[i] = argType;
+					genericArg = true;
+				}
+			}
+		}
+		ArgType retType = mth.getReturnType();
+		if (!retType.isGeneric() && !retType.isGenericType()) {
+			retType = null;
+		}
+		boolean varArgs = accessFlags.isVarArgs();
+		if (genericArg || retType != null || varArgs) {
+			methods.add(new NMethod(mth.getMethodInfo().getShortId(), genericArgs, retType, varArgs));
+		}
+	}
+
 	public static NClass[] makeParentsArray(ClassNode cls, Map<String, NClass> names) {
-		List<NClass> parents = new ArrayList<NClass>(1 + cls.getInterfaces().size());
+		List<NClass> parents = new ArrayList<>(1 + cls.getInterfaces().size());
 		ArgType superClass = cls.getSuperClass();
 		if (superClass != null) {
 			NClass c = getCls(superClass.getObject(), names);
@@ -92,106 +153,184 @@ public class ClsSet {
 				parents.add(c);
 			}
 		}
-		return parents.toArray(new NClass[parents.size()]);
+		int size = parents.size();
+		if (size == 0) {
+			return EMPTY_NCLASS_ARRAY;
+		}
+		return parents.toArray(new NClass[size]);
 	}
 
 	private static NClass getCls(String fullName, Map<String, NClass> names) {
-		NClass id = names.get(fullName);
-		if (id == null && !names.containsKey(fullName)) {
+		NClass cls = names.get(fullName);
+		if (cls == null) {
 			LOG.debug("Class not found: {}", fullName);
 		}
-		return id;
+		return cls;
 	}
 
-	void save(File output) throws IOException {
-		FileUtils.makeDirsForFile(output);
-
-		BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(output));
-		try {
-			String outputName = output.getName();
-			if (outputName.endsWith(CLST_EXTENSION)) {
+	void save(Path path) throws IOException {
+		FileUtils.makeDirsForFile(path);
+		String outputName = path.getFileName().toString();
+		if (outputName.endsWith(CLST_EXTENSION)) {
+			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);
-				} finally {
-					close(out);
-				}
-			} else {
-				throw new JadxRuntimeException("Unknown file format: " + outputName);
 			}
-		} finally {
-			close(outputStream);
+		} else if (outputName.endsWith(".jar")) {
+			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_PKG_PATH + '/' + CLST_FILENAME;
+				out.putNextEntry(new ZipEntry(clst));
+				save(out);
+				ZipEntry entry = in.getNextEntry();
+				while (entry != null) {
+					if (!entry.getName().equals(clst)) {
+						out.putNextEntry(new ZipEntry(entry.getName()));
+						FileUtils.copyStream(in, out);
+					}
+					entry = in.getNextEntry();
+				}
+			}
+		} else {
+			throw new JadxRuntimeException("Unknown file format: " + outputName);
 		}
 	}
 
 	public void save(OutputStream output) throws IOException {
 		DataOutputStream out = new DataOutputStream(output);
-		try {
-			out.writeBytes(JADX_CLS_SET_HEADER);
-			out.writeByte(VERSION);
+		out.writeBytes(JADX_CLS_SET_HEADER);
+		out.writeByte(VERSION);
 
-			LOG.info("Classes count: {}", classes.length);
-			out.writeInt(classes.length);
-			for (NClass cls : classes) {
-				writeString(out, cls.getName());
+		LOG.info("Classes count: {}", classes.length);
+		Map<String, NClass> names = new HashMap<>(classes.length);
+		out.writeInt(classes.length);
+		for (NClass cls : classes) {
+			writeString(out, cls.getName());
+			names.put(cls.getName(), cls);
+		}
+		for (NClass cls : classes) {
+			NClass[] parents = cls.getParents();
+			out.writeByte(parents.length);
+			for (NClass parent : parents) {
+				out.writeInt(parent.getId());
 			}
-			for (NClass cls : classes) {
-				NClass[] parents = cls.getParents();
-				out.writeByte(parents.length);
-				for (NClass parent : parents) {
-					out.writeInt(parent.getId());
+			writeGenerics(out, cls, names);
+			List<NMethod> methods = cls.getMethodsList();
+			out.writeByte(methods.size());
+			for (NMethod method : methods) {
+				writeMethod(out, method, names);
+			}
+		}
+	}
+
+	private static void writeGenerics(DataOutputStream out, NClass cls, Map<String, NClass> names) throws IOException {
+		List<GenericInfo> genericsList = cls.getGenerics();
+		out.writeByte(genericsList.size());
+		for (GenericInfo genericInfo : genericsList) {
+			writeArgType(out, genericInfo.getGenericType(), names);
+			List<ArgType> extendsList = genericInfo.getExtendsList();
+			out.writeByte(extendsList.size());
+			for (ArgType type : extendsList) {
+				writeArgType(out, type, names);
+			}
+
+		}
+	}
+
+	private static void writeMethod(DataOutputStream out, NMethod method, Map<String, NClass> names) throws IOException {
+		writeLongString(out, method.getShortId());
+
+		ArgType[] argTypes = method.getGenericArgs();
+		if (argTypes == null) {
+			out.writeByte(0);
+		} else {
+			int argCount = 0;
+			for (ArgType arg : argTypes) {
+				if (arg != null) {
+					argCount++;
 				}
 			}
-		} finally {
-			close(out);
+			out.writeByte(argCount);
+			// last argument first
+			for (int i = argTypes.length - 1; i >= 0; i--) {
+				ArgType argType = argTypes[i];
+				if (argType != null) {
+					out.writeByte(i);
+					writeArgType(out, argType, names);
+				}
+			}
+		}
+		if (method.getReturnType() == null) {
+			out.writeBoolean(false);
+		} else {
+			out.writeBoolean(true);
+			writeArgType(out, method.getReturnType(), names);
+		}
+		out.writeBoolean(method.isVarArgs());
+	}
+
+	private static void writeArgType(DataOutputStream out, ArgType argType, Map<String, NClass> names) throws IOException {
+		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(names.get(argType.getObject()).getId());
+			ArgType[] types = argType.getGenericTypes();
+			if (types == null) {
+				out.writeByte(0);
+			} else {
+				out.writeByte(types.length);
+				for (ArgType type : types) {
+					writeArgType(out, type, names);
+				}
+			}
+		} else if (argType.isGenericType()) {
+			out.writeByte(TypeEnum.GENERIC_TYPE.ordinal());
+			writeString(out, argType.getObject());
+		} else if (argType.isObject()) {
+			out.writeByte(TypeEnum.OBJECT.ordinal());
+			out.writeInt(names.get(argType.getObject()).getId());
+		} else if (argType.isArray()) {
+			out.writeByte(TypeEnum.ARRAY.ordinal());
+			writeArgType(out, argType.getArrayElement(), names);
+		} else if (argType.isPrimitive()) {
+			out.writeByte(TypeEnum.PRIMITIVE.ordinal());
+			out.writeByte(argType.getPrimitiveType().getShortName().charAt(0));
+		} else {
+			throw new JadxRuntimeException("Cannot save type: " + argType);
 		}
 	}
 
-	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);
-		}
-		try {
-			load(input);
-		} finally {
-			close(input);
-		}
-	}
-
-	public void load(File input) throws IOException, DecodeException {
+	private void load(File input) throws IOException, DecodeException {
 		String name = input.getName();
-		InputStream inputStream = new FileInputStream(input);
-		try {
+		try (InputStream inputStream = new FileInputStream(input)) {
 			if (name.endsWith(CLST_EXTENSION)) {
 				load(inputStream);
 			} else if (name.endsWith(".jar")) {
-				ZipInputStream in = new ZipInputStream(inputStream);
-				try {
+				try (ZipInputStream in = new ZipInputStream(inputStream)) {
 					ZipEntry entry = in.getNextEntry();
 					while (entry != null) {
-						if (entry.getName().endsWith(CLST_EXTENSION)) {
+						if (entry.getName().endsWith(CLST_EXTENSION) && ZipSecurity.isValidZipEntry(entry)) {
 							load(in);
 						}
 						entry = in.getNextEntry();
 					}
-				} finally {
-					close(in);
 				}
 			} else {
 				throw new JadxRuntimeException("Unknown file format: " + name);
 			}
-		} finally {
-			close(inputStream);
 		}
 	}
 
-	public void load(InputStream input) throws IOException, DecodeException {
-		DataInputStream in = new DataInputStream(input);
-		try {
+	private void load(InputStream input) throws IOException, DecodeException {
+		try (DataInputStream in = new DataInputStream(input)) {
 			byte[] header = new byte[JADX_CLS_SET_HEADER.length()];
 			int readHeaderLength = in.read(header);
 			int version = in.readByte();
@@ -212,21 +351,127 @@ public class ClsSet {
 				for (int j = 0; j < pCount; j++) {
 					parents[j] = classes[in.readInt()];
 				}
-				classes[i].setParents(parents);
+				NClass nClass = classes[i];
+				nClass.setParents(parents);
+				nClass.setGenerics(readGenerics(in));
+				nClass.setMethods(readClsMethods(in));
 			}
-		} finally {
-			close(in);
 		}
 	}
 
-	private void writeString(DataOutputStream out, String name) throws IOException {
+	private List<GenericInfo> readGenerics(DataInputStream in) throws IOException {
+		int count = in.readByte();
+		if (count == 0) {
+			return Collections.emptyList();
+		}
+		List<GenericInfo> list = new ArrayList<>(count);
+		for (int i = 0; i < count; i++) {
+			ArgType genericType = readArgType(in);
+			List<ArgType> extendsList;
+			byte extCount = in.readByte();
+			if (extCount == 0) {
+				extendsList = Collections.emptyList();
+			} else {
+				extendsList = new ArrayList<>(extCount);
+				for (int j = 0; j < extCount; j++) {
+					extendsList.add(readArgType(in));
+				}
+			}
+			list.add(new GenericInfo(genericType, extendsList));
+		}
+		return list;
+	}
+
+	private List<NMethod> readClsMethods(DataInputStream in) throws IOException {
+		int mCount = in.readByte();
+		List<NMethod> methods = new ArrayList<>(mCount);
+		for (int j = 0; j < mCount; j++) {
+			methods.add(readMethod(in));
+		}
+		return methods;
+	}
+
+	private NMethod readMethod(DataInputStream in) throws IOException {
+		String shortId = readLongString(in);
+		int argCount = in.readByte();
+		ArgType[] argTypes = null;
+		for (int i = 0; i < argCount; i++) {
+			int index = in.readByte();
+			ArgType argType = readArgType(in);
+			if (argTypes == null) {
+				argTypes = new ArgType[index + 1];
+			}
+			argTypes[index] = argType;
+		}
+		ArgType retType = in.readBoolean() ? readArgType(in) : null;
+		boolean varArgs = in.readBoolean();
+		return new NMethod(shortId, argTypes, retType, varArgs);
+	}
+
+	private ArgType readArgType(DataInputStream in) throws IOException {
+		int ordinal = in.readByte();
+		switch (TypeEnum.values()[ordinal]) {
+			case WILDCARD:
+				int bounds = in.readByte();
+				return bounds == 0
+						? ArgType.wildcard()
+						: ArgType.wildcard(readArgType(in), ArgType.WildcardBound.getByNum(bounds));
+
+			case GENERIC:
+				String obj = classes[in.readInt()].getName();
+				int typeLength = in.readByte();
+				ArgType[] generics;
+				if (typeLength == 0) {
+					generics = null;
+				} else {
+					generics = new ArgType[typeLength];
+					for (int i = 0; i < typeLength; i++) {
+						generics[i] = readArgType(in);
+					}
+				}
+				return ArgType.generic(obj, generics);
+
+			case GENERIC_TYPE:
+				return ArgType.genericType(readString(in));
+
+			case OBJECT:
+				return ArgType.object(classes[in.readInt()].getName());
+
+			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);
 		out.write(bytes);
 	}
 
+	private static void writeLongString(DataOutputStream out, String name) throws IOException {
+		byte[] bytes = name.getBytes(STRING_CHARSET);
+		out.writeShort(bytes.length);
+		out.write(bytes);
+	}
+
 	private static String readString(DataInputStream in) throws IOException {
 		int len = in.readByte();
+		return readString(in, len);
+	}
+
+	private static String readLongString(DataInputStream in) throws IOException {
+		int len = in.readShort();
+		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) {

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

@@ -1,9 +1,5 @@
 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;
@@ -14,29 +10,36 @@ 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.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 final Map<String, Set<String>> ancestorCache = Collections.synchronizedMap(new WeakHashMap<>());
 	private Map<String, NClass> nameMap;
 
-	private final Set<String> missingClasses = new HashSet<String>();
+	private final Set<String> missingClasses = new HashSet<>();
 
 	public void load() throws IOException, DecodeException {
 		ClsSet set = new ClsSet();
-		set.load();
+		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");
@@ -58,6 +61,23 @@ public class ClspGraph {
 		}
 	}
 
+	public boolean isClsKnown(String fullName) {
+		return nameMap.containsKey(fullName);
+	}
+
+	public NClass getClsDetails(ArgType type) {
+		return nameMap.get(type.getObject());
+	}
+
+	@Nullable
+	public NMethod getMethodDetails(MethodInfo methodInfo) {
+		NClass cls = nameMap.get(methodInfo.getDeclClass().getRawName());
+		if (cls == null) {
+			return null;
+		}
+		return cls.getMethodsMap().get(methodInfo.getShortId());
+	}
+
 	private NClass addClass(ClassNode cls) {
 		String rawName = cls.getRawName();
 		NClass nClass = new NClass(rawName, -1);
@@ -65,11 +85,24 @@ public class ClspGraph {
 		return nClass;
 	}
 
+	/**
+	 * @return {@code clsName} instanceof {@code implClsName}
+	 */
 	public boolean isImplements(String clsName, String implClsName) {
 		Set<String> anc = getAncestors(clsName);
 		return anc.contains(implClsName);
 	}
 
+	public List<String> getImplementations(String clsName) {
+		List<String> list = new ArrayList<>();
+		for (String cls : nameMap.keySet()) {
+			if (isImplements(cls, clsName)) {
+				list.add(cls);
+			}
+		}
+		return list;
+	}
+
 	public String getCommonAncestor(String clsName, String implClsName) {
 		if (clsName.equals(implClsName)) {
 			return clsName;
@@ -100,7 +133,7 @@ public class ClspGraph {
 		return null;
 	}
 
-	private Set<String> getAncestors(String clsName) {
+	public Set<String> getAncestors(String clsName) {
 		Set<String> result = ancestorCache.get(clsName);
 		if (result != null) {
 			return result;
@@ -110,7 +143,7 @@ public class ClspGraph {
 			missingClasses.add(clsName);
 			return Collections.emptySet();
 		}
-		result = new HashSet<String>();
+		result = new HashSet<>();
 		addAncestorsNames(cls, result);
 		if (result.isEmpty()) {
 			result = Collections.emptySet();
@@ -120,9 +153,11 @@ public class ClspGraph {
 	}
 
 	private void addAncestorsNames(NClass cls, Set<String> result) {
-		result.add(cls.getName());
-		for (NClass p : cls.getParents()) {
-			addAncestorsNames(p, result);
+		boolean isNew = result.add(cls.getName());
+		if (isNew) {
+			for (NClass p : cls.getParents()) {
+				addAncestorsNames(p, result);
+			}
 		}
 	}
 
@@ -133,7 +168,7 @@ public class ClspGraph {
 		}
 		LOG.warn("Found {} references to unknown classes", count);
 		if (LOG.isDebugEnabled()) {
-			List<String> clsNames = new ArrayList<String>(missingClasses);
+			List<String> clsNames = new ArrayList<>(missingClasses);
 			Collections.sort(clsNames);
 			for (String cls : clsNames) {
 				LOG.debug("  {}", cls);

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

@@ -1,18 +1,20 @@
 package jadx.core.clsp;
 
-import jadx.api.JadxArgs;
-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.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.JadxArgs;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.exceptions.DecodeException;
+import jadx.core.utils.files.InputFile;
+
 /**
  * Utility class for convert dex or jar to jadx classes set (.jcst)
  */
@@ -28,15 +30,15 @@ public class ConvertToClsSet {
 			usage();
 			System.exit(1);
 		}
-		File output = new File(args[0]);
+		Path output = Paths.get(args[0]);
 
-		List<InputFile> inputFiles = new ArrayList<InputFile>(args.length - 1);
+		List<InputFile> inputFiles = new ArrayList<>(args.length - 1);
 		for (int i = 1; i < args.length; i++) {
 			File f = new File(args[i]);
 			if (f.isDirectory()) {
 				addFilesFromDirectory(f, inputFiles);
 			} else {
-				InputFile.addFilesFrom(f, inputFiles);
+				InputFile.addFilesFrom(f, inputFiles, false);
 			}
 		}
 		for (InputFile inputFile : inputFiles) {
@@ -47,7 +49,7 @@ public class ConvertToClsSet {
 		root.load(inputFiles);
 
 		ClsSet set = new ClsSet();
-		set.load(root);
+		set.loadFrom(root);
 		set.save(output);
 		LOG.info("Output: {}", output);
 		LOG.info("done");
@@ -63,7 +65,7 @@ public class ConvertToClsSet {
 				addFilesFromDirectory(file, inputFiles);
 			} else {
 				try {
-					InputFile.addFilesFrom(file, inputFiles);
+					InputFile.addFilesFrom(file, inputFiles, false);
 				} catch (Exception e) {
 					LOG.warn("Skip file: {}, load error: {}", file, e.getMessage());
 				}

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

@@ -1,13 +1,24 @@
 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.nodes.GenericInfo;
+
 /**
  * Class node in classpath graph
  */
 public class NClass {
 
 	private final String name;
+	private final int id;
 	private NClass[] parents;
-	private int id;
+	private Map<String, NMethod> methodsMap = Collections.emptyMap();
+	private List<GenericInfo> generics = Collections.emptyList();
 
 	public NClass(String name, int id) {
 		this.name = name;
@@ -22,10 +33,6 @@ public class NClass {
 		return id;
 	}
 
-	public void setId(int id) {
-		this.id = id;
-	}
-
 	public NClass[] getParents() {
 		return parents;
 	}
@@ -34,6 +41,37 @@ public class NClass {
 		this.parents = parents;
 	}
 
+	public Map<String, NMethod> getMethodsMap() {
+		return methodsMap;
+	}
+
+	public List<NMethod> getMethodsList() {
+		List<NMethod> list = new ArrayList<>(methodsMap.size());
+		list.addAll(methodsMap.values());
+		Collections.sort(list);
+		return list;
+	}
+
+	public void setMethodsMap(Map<String, NMethod> methodsMap) {
+		this.methodsMap = Objects.requireNonNull(methodsMap);
+	}
+
+	public void setMethods(List<NMethod> methods) {
+		Map<String, NMethod> map = new HashMap<>(methods.size());
+		for (NMethod mth : methods) {
+			map.put(mth.getShortId(), mth);
+		}
+		setMethodsMap(map);
+	}
+
+	public List<GenericInfo> getGenerics() {
+		return generics;
+	}
+
+	public void setGenerics(List<GenericInfo> generics) {
+		this.generics = generics;
+	}
+
 	@Override
 	public int hashCode() {
 		return name.hashCode();

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

@@ -0,0 +1,92 @@
+package jadx.core.clsp;
+
+import java.util.Arrays;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.core.dex.instructions.args.ArgType;
+
+/**
+ * Generic method node in classpath graph.
+ */
+public class NMethod implements Comparable<NMethod> {
+
+	private final String shortId;
+
+	/**
+	 * Array contains only generic args, others set to 'null', size can be less than total args count
+	 */
+	@Nullable
+	private final ArgType[] genericArgs;
+
+	@Nullable
+	private final ArgType retType;
+
+	private final boolean varArgs;
+
+	public NMethod(String shortId, @Nullable ArgType[] genericArgs, @Nullable ArgType retType, boolean varArgs) {
+		this.shortId = shortId;
+		this.genericArgs = genericArgs;
+		this.retType = retType;
+		this.varArgs = varArgs;
+	}
+
+	public String getShortId() {
+		return shortId;
+	}
+
+	@Nullable
+	public ArgType[] getGenericArgs() {
+		return genericArgs;
+	}
+
+	@Nullable
+	public ArgType getGenericArg(int i) {
+		ArgType[] args = this.genericArgs;
+		if (args != null && i < args.length) {
+			return args[i];
+		}
+		return null;
+	}
+
+	@Nullable
+	public ArgType getReturnType() {
+		return retType;
+	}
+
+	public boolean isVarArgs() {
+		return varArgs;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof NMethod)) {
+			return false;
+		}
+		NMethod other = (NMethod) o;
+		return shortId.equals(other.shortId);
+	}
+
+	@Override
+	public int hashCode() {
+		return shortId.hashCode();
+	}
+
+	@Override
+	public int compareTo(@NotNull NMethod other) {
+		return this.shortId.compareTo(other.shortId);
+	}
+
+	@Override
+	public String toString() {
+		return "NMethod{'" + shortId + '\''
+				+ ", argTypes=" + Arrays.toString(genericArgs)
+				+ ", retType=" + retType
+				+ ", varArgs=" + varArgs
+				+ '}';
+	}
+}

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

@@ -1,5 +1,12 @@
 package jadx.core.codegen;
 
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.jetbrains.annotations.Nullable;
+
 import jadx.core.Consts;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttributeNode;
@@ -14,11 +21,6 @@ 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;
-
 public class AnnotationGen {
 
 	private final ClassNode cls;
@@ -63,12 +65,7 @@ public class AnnotationGen {
 		}
 		for (Annotation a : aList.getAll()) {
 			String aCls = a.getAnnotationClass();
-			if (aCls.startsWith(Consts.DALVIK_ANNOTATION_PKG)) {
-				// skip
-				if (Consts.DEBUG) {
-					code.startLine("// " + a);
-				}
-			} else {
+			if (!aCls.startsWith(Consts.DALVIK_ANNOTATION_PKG)) {
 				code.startLine();
 				formatAnnotation(code, a);
 			}
@@ -77,34 +74,52 @@ public class AnnotationGen {
 
 	private void formatAnnotation(CodeWriter code, Annotation a) {
 		code.add('@');
-		classGen.useType(code, a.getType());
+		ClassNode annCls = cls.dex().resolveClass(a.getType());
+		if (annCls != null) {
+			classGen.useClass(code, annCls);
+		} else {
+			classGen.useType(code, a.getType());
+		}
+
 		Map<String, Object> vl = a.getValues();
 		if (!vl.isEmpty()) {
 			code.add('(');
-			if (vl.size() == 1 && vl.containsKey("value")) {
-				encodeValue(code, 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, Object>> it = vl.entrySet().iterator(); it.hasNext();) {
+				Entry<String, Object> 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(" = ");
-					encodeValue(code, e.getValue());
-					if (it.hasNext()) {
-						code.add(", ");
-					}
+				}
+				encodeValue(code, e.getValue());
+				if (it.hasNext()) {
+					code.add(", ");
 				}
 			}
 			code.add(')');
 		}
 	}
 
+	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;
+	}
+
 	@SuppressWarnings("unchecked")
 	public void addThrows(MethodNode mth, CodeWriter code) {
 		Annotation an = mth.getAnnotation(Consts.DALVIK_THROWS);
 		if (an != null) {
 			Object exs = an.getDefaultValue();
 			code.add(" throws ");
-			for (Iterator<ArgType> it = ((List<ArgType>) exs).iterator(); it.hasNext(); ) {
+			for (Iterator<ArgType> it = ((List<ArgType>) exs).iterator(); it.hasNext();) {
 				ArgType ex = it.next();
 				classGen.useType(code, ex);
 				if (it.hasNext()) {
@@ -132,7 +147,7 @@ public class AnnotationGen {
 		if (val instanceof String) {
 			code.add(getStringUtils().unescapeString((String) val));
 		} else if (val instanceof Integer) {
-			code.add(TypeGen.formatInteger((Integer) val));
+			code.add(TypeGen.formatInteger((Integer) val, false));
 		} else if (val instanceof Character) {
 			code.add(getStringUtils().unescapeChar((Character) val));
 		} else if (val instanceof Boolean) {
@@ -142,11 +157,11 @@ public class AnnotationGen {
 		} else if (val instanceof Double) {
 			code.add(TypeGen.formatDouble((Double) val));
 		} else if (val instanceof Long) {
-			code.add(TypeGen.formatLong((Long) val));
+			code.add(TypeGen.formatLong((Long) val, false));
 		} else if (val instanceof Short) {
-			code.add(TypeGen.formatShort((Short) val));
+			code.add(TypeGen.formatShort((Short) val, false));
 		} else if (val instanceof Byte) {
-			code.add(TypeGen.formatByte((Byte) val));
+			code.add(TypeGen.formatByte((Byte) val, false));
 		} else if (val instanceof ArgType) {
 			classGen.useType(code, (ArgType) val);
 			code.add(".class");
@@ -156,7 +171,7 @@ public class AnnotationGen {
 			InsnGen.makeStaticFieldAccess(code, field, classGen);
 		} else if (val instanceof Iterable) {
 			code.add('{');
-			Iterator<?> it = ((Iterable) val).iterator();
+			Iterator<?> it = ((Iterable<?>) val).iterator();
 			while (it.hasNext()) {
 				Object obj = it.next();
 				encodeValue(code, obj);
@@ -169,7 +184,7 @@ public class AnnotationGen {
 			formatAnnotation(code, (Annotation) val);
 		} else {
 			// TODO: also can be method values
-			throw new JadxRuntimeException("Can't decode value: " + val + " (" + val.getClass() + ")");
+			throw new JadxRuntimeException("Can't decode value: " + val + " (" + val.getClass() + ')');
 		}
 	}
 

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

@@ -1,12 +1,25 @@
 package jadx.core.codegen;
 
-import jadx.api.IJadxArgs;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+import com.android.dx.rop.code.AccessFlags;
+import com.google.common.collect.Streams;
+
+import jadx.api.JadxArgs;
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.AttrNode;
 import jadx.core.dex.attributes.nodes.EnumClassAttr;
 import jadx.core.dex.attributes.nodes.EnumClassAttr.EnumField;
-import jadx.core.dex.attributes.nodes.SourceFileAttr;
+import jadx.core.dex.attributes.nodes.JadxError;
+import jadx.core.dex.attributes.nodes.LineAttrNode;
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.info.ClassInfo;
 import jadx.core.dex.instructions.args.ArgType;
@@ -15,60 +28,42 @@ import jadx.core.dex.instructions.mods.ConstructorInsn;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.DexNode;
 import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.GenericInfo;
 import jadx.core.dex.nodes.InsnNode;
 import jadx.core.dex.nodes.MethodNode;
 import jadx.core.dex.nodes.parser.FieldInitAttr;
 import jadx.core.dex.nodes.parser.FieldInitAttr.InitType;
+import jadx.core.utils.CodeGenUtils;
 import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.Utils;
 import jadx.core.utils.exceptions.CodegenException;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.android.dx.rop.code.AccessFlags;
+import jadx.core.utils.exceptions.JadxRuntimeException;
 
 public class ClassGen {
-	private static final Logger LOG = LoggerFactory.getLogger(ClassGen.class);
-
-	public static final Comparator<MethodNode> METHOD_LINE_COMPARATOR = new Comparator<MethodNode>() {
-		@Override
-		public int compare(MethodNode a, MethodNode b) {
-			return Utils.compare(a.getSourceLine(), b.getSourceLine());
-		}
-	};
 
 	private final ClassNode cls;
 	private final ClassGen parentGen;
 	private final AnnotationGen annotationGen;
 	private final boolean fallback;
+	private final boolean useImports;
 	private final boolean showInconsistentCode;
 
-	private final Set<ClassInfo> imports = new HashSet<ClassInfo>();
+	private final Set<ClassInfo> imports = new HashSet<>();
 	private int clsDeclLine;
 
-	public ClassGen(ClassNode cls, IJadxArgs jadxArgs) {
-		this(cls, null, jadxArgs.isFallbackMode(), jadxArgs.isShowInconsistentCode());
+	public ClassGen(ClassNode cls, JadxArgs jadxArgs) {
+		this(cls, null, jadxArgs.isUseImports(), jadxArgs.isFallbackMode(), jadxArgs.isShowInconsistentCode());
 	}
 
 	public ClassGen(ClassNode cls, ClassGen parentClsGen) {
-		this(cls, parentClsGen, parentClsGen.fallback, parentClsGen.showInconsistentCode);
+		this(cls, parentClsGen, parentClsGen.useImports, parentClsGen.fallback, parentClsGen.showInconsistentCode);
 	}
 
-	public ClassGen(ClassNode cls, ClassGen parentClsGen, boolean fallback, boolean showBadCode) {
+	public ClassGen(ClassNode cls, ClassGen parentClsGen, boolean useImports, boolean fallback, boolean showBadCode) {
 		this.cls = cls;
 		this.parentGen = parentClsGen;
 		this.fallback = fallback;
+		this.useImports = useImports;
 		this.showInconsistentCode = showBadCode;
 
 		this.annotationGen = new AnnotationGen(cls, this);
@@ -89,31 +84,30 @@ public class ClassGen {
 		}
 		int importsCount = imports.size();
 		if (importsCount != 0) {
-			List<String> sortImports = new ArrayList<String>(importsCount);
-			for (ClassInfo ic : imports) {
-				sortImports.add(ic.getAlias().getFullName());
-			}
-			Collections.sort(sortImports);
-
-			for (String imp : sortImports) {
-				clsCode.startLine("import ").add(imp).add(';');
-			}
+			List<ClassInfo> sortedImports = new ArrayList<>(imports);
+			sortedImports.sort(Comparator.comparing(ClassInfo::getAliasFullName));
+			sortedImports.forEach(classInfo -> {
+				clsCode.startLine("import ");
+				ClassNode classNode = cls.root().resolveClass(classInfo);
+				if (classNode != null) {
+					clsCode.attachAnnotation(classNode);
+				}
+				clsCode.add(classInfo.getAliasFullName());
+				clsCode.add(';');
+			});
 			clsCode.newLine();
-
-			sortImports.clear();
 			imports.clear();
 		}
 		clsCode.add(clsBody);
-		return clsCode;
+		return clsCode.finish();
 	}
 
 	public void addClassCode(CodeWriter code) throws CodegenException {
 		if (cls.contains(AFlag.DONT_GENERATE)) {
 			return;
 		}
-		if (cls.contains(AFlag.INCONSISTENT_CODE)) {
-			code.startLine("// jadx: inconsistent code");
-		}
+		CodeGenUtils.addComments(code, cls);
+		insertDecompilationProblems(code, cls);
 		addClassDeclaration(code);
 		addClassBody(code);
 	}
@@ -130,14 +124,15 @@ public class ClassGen {
 		}
 
 		// 'static' and 'private' modifier not allowed for top classes (not inner)
-		if (!cls.getAlias().isInner()) {
+		if (!cls.getClassInfo().isInner()) {
 			af = af.remove(AccessFlags.ACC_STATIC).remove(AccessFlags.ACC_PRIVATE);
 		}
 
 		annotationGen.addForClass(clsCode);
-		insertSourceFileInfo(clsCode, cls);
 		insertRenameInfo(clsCode, cls);
-		clsCode.startLine(af.makeString());
+		CodeGenUtils.addSourceFileInfo(clsCode, cls);
+		clsCode.startLineWithNum(cls.getSourceLine());
+		clsCode.add(af.makeString());
 		if (af.isInterface()) {
 			if (af.isAnnotation()) {
 				clsCode.add('@');
@@ -149,15 +144,15 @@ public class ClassGen {
 			clsCode.add("class ");
 		}
 		clsCode.attachDefinition(cls);
-		clsCode.add(cls.getShortName());
+		clsCode.add(cls.getClassInfo().getAliasShortName());
 
-		addGenericMap(clsCode, cls.getGenericMap());
+		addGenericMap(clsCode, cls.getGenerics(), true);
 		clsCode.add(' ');
 
 		ArgType sup = cls.getSuperClass();
 		if (sup != null
 				&& !sup.equals(ArgType.OBJECT)
-				&& !sup.getObject().equals(ArgType.ENUM.getObject())) {
+				&& !cls.isEnum()) {
 			clsCode.add("extends ");
 			useClass(clsCode, sup);
 			clsCode.add(' ');
@@ -169,7 +164,7 @@ public class ClassGen {
 			} else {
 				clsCode.add("implements ");
 			}
-			for (Iterator<ArgType> it = cls.getInterfaces().iterator(); it.hasNext(); ) {
+			for (Iterator<ArgType> it = cls.getInterfaces().iterator(); it.hasNext();) {
 				ArgType interf = it.next();
 				useClass(clsCode, interf);
 				if (it.hasNext()) {
@@ -182,31 +177,36 @@ public class ClassGen {
 		}
 	}
 
-	public boolean addGenericMap(CodeWriter code, Map<ArgType, List<ArgType>> gmap) {
-		if (gmap == null || gmap.isEmpty()) {
+	public boolean addGenericMap(CodeWriter code, List<GenericInfo> generics, boolean classDeclaration) {
+		if (generics == null || generics.isEmpty()) {
 			return false;
 		}
 		code.add('<');
 		int i = 0;
-		for (Entry<ArgType, List<ArgType>> e : gmap.entrySet()) {
-			ArgType type = e.getKey();
-			List<ArgType> list = e.getValue();
+		for (GenericInfo genericInfo : generics) {
 			if (i != 0) {
 				code.add(", ");
 			}
+			ArgType type = genericInfo.getGenericType();
 			if (type.isGenericType()) {
 				code.add(type.getObject());
 			} else {
 				useClass(code, type);
 			}
+			List<ArgType> list = genericInfo.getExtendsList();
 			if (list != null && !list.isEmpty()) {
 				code.add(" extends ");
-				for (Iterator<ArgType> it = list.iterator(); it.hasNext(); ) {
+				for (Iterator<ArgType> it = list.iterator(); it.hasNext();) {
 					ArgType g = it.next();
 					if (g.isGenericType()) {
 						code.add(g.getObject());
 					} else {
 						useClass(code, g);
+						if (classDeclaration
+								&& !cls.getClassInfo().isInner()
+								&& cls.root().getArgs().isUseImports()) {
+							addImport(ClassInfo.fromType(cls.root(), g));
+						}
 					}
 					if (it.hasNext()) {
 						code.add(" & ");
@@ -224,22 +224,32 @@ public class ClassGen {
 		clsDeclLine = clsCode.getLine();
 		clsCode.incIndent();
 		addFields(clsCode);
-		addInnerClasses(clsCode, cls);
-		addMethods(clsCode);
+		addInnerClsAndMethods(clsCode);
 		clsCode.decIndent();
 		clsCode.startLine('}');
 	}
 
-	private void addInnerClasses(CodeWriter code, ClassNode cls) throws CodegenException {
-		for (ClassNode innerCls : cls.getInnerClasses()) {
-			if (innerCls.contains(AFlag.DONT_GENERATE)
-					|| innerCls.contains(AFlag.ANONYMOUS_CLASS)) {
-				continue;
-			}
+	private void addInnerClsAndMethods(CodeWriter clsCode) {
+		Streams.concat(cls.getInnerClasses().stream(), cls.getMethods().stream())
+				.filter(node -> !node.contains(AFlag.DONT_GENERATE))
+				.sorted(Comparator.comparingInt(LineAttrNode::getSourceLine))
+				.forEach(node -> {
+					if (node instanceof ClassNode) {
+						addInnerClass(clsCode, (ClassNode) node);
+					} else {
+						addMethod(clsCode, (MethodNode) node);
+					}
+				});
+	}
+
+	private void addInnerClass(CodeWriter code, ClassNode innerCls) {
+		try {
 			ClassGen inClGen = new ClassGen(innerCls, getParentGen());
 			code.newLine();
 			inClGen.addClassCode(code);
 			imports.addAll(inClGen.getImports());
+		} catch (Exception e) {
+			ErrorsCounter.classError(innerCls, "Inner class code generation error", e);
 		}
 	}
 
@@ -252,30 +262,24 @@ public class ClassGen {
 		return false;
 	}
 
-	private void addMethods(CodeWriter code) {
-		List<MethodNode> methods = sortMethodsByLine(cls.getMethods());
-		for (MethodNode mth : methods) {
-			if (mth.contains(AFlag.DONT_GENERATE)) {
-				continue;
-			}
-			if (code.getLine() != clsDeclLine) {
-				code.newLine();
-			}
-			try {
-				addMethod(code, mth);
-			} catch (Exception e) {
-				code.newLine().add("/*");
-				code.newLine().add(ErrorsCounter.methodError(mth, "Method generation error", e));
-				code.newLine().add(Utils.getStackTrace(e));
-				code.newLine().add("*/");
-			}
+	private void addMethod(CodeWriter code, MethodNode mth) {
+		if (code.getLine() != clsDeclLine) {
+			code.newLine();
+		}
+		int savedIndent = code.getIndent();
+		try {
+			addMethodCode(code, mth);
+		} catch (Exception e) {
+			if (mth.getParentClass().getTopParentClass().contains(AFlag.RESTART_CODEGEN)) {
+				throw new JadxRuntimeException("Method generation error", e);
+			}
+			code.newLine().add("/*");
+			code.newLine().addMultiLine(ErrorsCounter.methodError(mth, "Method generation error", e));
+			Utils.appendStackTrace(code, e);
+			code.newLine().add("*/");
+			code.setIndent(savedIndent);
+			mth.addError("Method generation error: " + e.getMessage(), e);
 		}
-	}
-
-	private static List<MethodNode> sortMethodsByLine(List<MethodNode> methods) {
-		List<MethodNode> out = new ArrayList<MethodNode>(methods);
-		Collections.sort(out, METHOD_LINE_COMPARATOR);
-		return out;
 	}
 
 	private boolean isMethodsPresents() {
@@ -287,31 +291,21 @@ public class ClassGen {
 		return false;
 	}
 
-	private void addMethod(CodeWriter code, MethodNode mth) throws CodegenException {
+	public void addMethodCode(CodeWriter code, MethodNode mth) throws CodegenException {
+		CodeGenUtils.addComments(code, mth);
 		if (mth.getAccessFlags().isAbstract() || mth.getAccessFlags().isNative()) {
 			MethodGen mthGen = new MethodGen(this, mth);
 			mthGen.addDefinition(code);
-			if (cls.getAccessFlags().isAnnotation()) {
-				Object def = annotationGen.getAnnotationDefaultValue(mth.getName());
-				if (def != null) {
-					code.add(" default ");
-					annotationGen.encodeValue(code, def);
-				}
-			}
 			code.add(';');
 		} else {
+			insertDecompilationProblems(code, mth);
 			boolean badCode = mth.contains(AFlag.INCONSISTENT_CODE);
-			if (badCode) {
-				code.startLine("/* JADX WARNING: inconsistent code. */");
-				code.startLine("/* Code decompiled incorrectly, please refer to instructions dump. */");
-				ErrorsCounter.methodError(mth, "Inconsistent code");
-				if (showInconsistentCode) {
-					mth.remove(AFlag.INCONSISTENT_CODE);
-					badCode = false;
-				}
+			if (badCode && showInconsistentCode) {
+				mth.remove(AFlag.INCONSISTENT_CODE);
+				badCode = false;
 			}
 			MethodGen mthGen;
-			if (badCode || mth.contains(AType.JADX_ERROR) || fallback) {
+			if (badCode || fallback || mth.contains(AType.JADX_ERROR) || mth.getRegion() == null) {
 				mthGen = MethodGen.getFallbackMethodGen(mth);
 			} else {
 				mthGen = new MethodGen(this, mth);
@@ -321,45 +315,71 @@ public class ClassGen {
 			}
 			code.add('{');
 			code.incIndent();
-			insertSourceFileInfo(code, mth);
-			if (fallback) {
-				mthGen.addFallbackMethodCode(code);
-			} else {
-				mthGen.addInstructions(code);
-			}
+			mthGen.addInstructions(code);
 			code.decIndent();
 			code.startLine('}');
 		}
 	}
 
+	public void insertDecompilationProblems(CodeWriter code, AttrNode node) {
+		List<JadxError> errors = node.getAll(AType.JADX_ERROR);
+		if (!errors.isEmpty()) {
+			errors.stream().distinct().sorted().forEach(err -> {
+				code.startLine("/*  JADX ERROR: ").add(err.getError());
+				Throwable cause = err.getCause();
+				if (cause != null) {
+					code.incIndent();
+					Utils.appendStackTrace(code, cause);
+					code.decIndent();
+				}
+				code.add("*/");
+			});
+		}
+		List<String> warns = node.getAll(AType.JADX_WARN);
+		if (!warns.isEmpty()) {
+			warns.stream().distinct().sorted()
+					.forEach(warn -> code.startLine("/* JADX WARNING: ").addMultiLine(warn).add(" */"));
+		}
+	}
+
 	private void addFields(CodeWriter code) throws CodegenException {
 		addEnumFields(code);
 		for (FieldNode f : cls.getFields()) {
-			if (f.contains(AFlag.DONT_GENERATE)) {
-				continue;
-			}
-			annotationGen.addForField(code, f);
-			code.startLine(f.getAccessFlags().makeString());
-			useType(code, f.getType());
-			code.add(' ');
-			code.attachDefinition(f);
-			code.add(f.getAlias());
-			FieldInitAttr fv = f.get(AType.FIELD_INIT);
-			if (fv != null) {
-				code.add(" = ");
-				if (fv.getValue() == null) {
-					code.add(TypeGen.literalToString(0, f.getType(), cls));
-				} else {
-					if (fv.getValueType() == InitType.CONST) {
-						annotationGen.encodeValue(code, fv.getValue());
-					} else if (fv.getValueType() == InitType.INSN) {
-						InsnGen insnGen = makeInsnGen(fv.getInsnMth());
-						addInsnBody(insnGen, code, fv.getInsn());
-					}
+			addField(code, f);
+		}
+	}
+
+	public void addField(CodeWriter code, FieldNode f) {
+		if (f.contains(AFlag.DONT_GENERATE)) {
+			return;
+		}
+		CodeGenUtils.addComments(code, f);
+		annotationGen.addForField(code, f);
+
+		if (f.getFieldInfo().isRenamed()) {
+			code.newLine();
+			CodeGenUtils.addRenamedComment(code, f, f.getName());
+		}
+		code.startLine(f.getAccessFlags().makeString());
+		useType(code, f.getType());
+		code.add(' ');
+		code.attachDefinition(f);
+		code.add(f.getAlias());
+		FieldInitAttr fv = f.get(AType.FIELD_INIT);
+		if (fv != null) {
+			code.add(" = ");
+			if (fv.getValue() == null) {
+				code.add(TypeGen.literalToString(0, f.getType(), cls, fallback));
+			} else {
+				if (fv.getValueType() == InitType.CONST) {
+					annotationGen.encodeValue(code, fv.getValue());
+				} else if (fv.getValueType() == InitType.INSN) {
+					InsnGen insnGen = makeInsnGen(fv.getInsnMth());
+					addInsnBody(insnGen, code, fv.getInsn());
 				}
 			}
-			code.add(';');
 		}
+		code.add(';');
 	}
 
 	private boolean isFieldsPresents() {
@@ -377,7 +397,7 @@ public class ClassGen {
 			return;
 		}
 		InsnGen igen = null;
-		for (Iterator<EnumField> it = enumFields.getFields().iterator(); it.hasNext(); ) {
+		for (Iterator<EnumField> it = enumFields.getFields().iterator(); it.hasNext();) {
 			EnumField f = it.next();
 			code.startLine(f.getField().getAlias());
 			ConstructorInsn constrInsn = f.getConstrInsn();
@@ -439,7 +459,15 @@ public class ClassGen {
 	}
 
 	public void useClass(CodeWriter code, ArgType type) {
-		useClass(code, ClassInfo.extCls(cls.dex(), type));
+		ArgType outerType = type.getOuterType();
+		if (outerType != null) {
+			useClass(code, outerType);
+			code.add('.');
+			useClass(code, type.getInnerType());
+			return;
+		}
+
+		useClass(code, ClassInfo.fromType(cls.root(), type));
 		ArgType[] generics = type.getGenericTypes();
 		if (generics != null) {
 			code.add('<');
@@ -451,10 +479,9 @@ public class ClassGen {
 				ArgType gt = generics[i];
 				ArgType wt = gt.getWildcardType();
 				if (wt != null) {
-					code.add('?');
-					int bounds = gt.getWildcardBounds();
-					if (bounds != 0) {
-						code.add(bounds == -1 ? " super " : " extends ");
+					ArgType.WildcardBound bound = gt.getWildcardBound();
+					code.add(bound.getStr());
+					if (bound != ArgType.WildcardBound.UNBOUND) {
 						useType(code, wt);
 					}
 				} else {
@@ -468,24 +495,37 @@ public class ClassGen {
 	public void useClass(CodeWriter code, ClassInfo classInfo) {
 		ClassNode classNode = cls.dex().resolveClass(classInfo);
 		if (classNode != null) {
-			code.attachAnnotation(classNode);
+			useClass(code, classNode);
+		} else {
+			addClsName(code, classInfo);
 		}
-		String baseClass = useClassInternal(cls.getAlias(), classInfo.getAlias());
-		code.add(baseClass);
+	}
+
+	public void useClass(CodeWriter code, ClassNode classNode) {
+		code.attachAnnotation(classNode);
+		addClsName(code, classNode.getClassInfo());
+	}
+
+	private void addClsName(CodeWriter code, ClassInfo classInfo) {
+		String clsName = useClassInternal(cls.getClassInfo(), classInfo);
+		code.add(clsName);
 	}
 
 	private String useClassInternal(ClassInfo useCls, ClassInfo extClsInfo) {
-		String fullName = extClsInfo.getFullName();
-		if (fallback) {
+		String fullName = extClsInfo.getAliasFullName();
+		if (fallback || !useImports) {
 			return fullName;
 		}
-		String shortName = extClsInfo.getShortName();
+		String shortName = extClsInfo.getAliasShortName();
 		if (extClsInfo.getPackage().equals("java.lang") && extClsInfo.getParentClass() == null) {
 			return shortName;
 		}
 		if (isClassInnerFor(useCls, extClsInfo)) {
 			return shortName;
 		}
+		if (extClsInfo.isInner()) {
+			return expandInnerClassName(useCls, extClsInfo);
+		}
 		if (isBothClassesInOneTopClass(useCls, extClsInfo)) {
 			return shortName;
 		}
@@ -505,15 +545,15 @@ public class ClassGen {
 		if (extClsInfo.isDefaultPackage()) {
 			return shortName;
 		}
-		if (extClsInfo.getPackage().equals(useCls.getPackage())) {
-			fullName = extClsInfo.getNameWithoutPackage();
+		if (extClsInfo.getAliasPkg().equals(useCls.getAliasPkg())) {
+			fullName = extClsInfo.getAliasNameWithoutPackage();
 		}
 		for (ClassInfo importCls : getImports()) {
 			if (!importCls.equals(extClsInfo)
-					&& importCls.getShortName().equals(shortName)) {
+					&& importCls.getAliasShortName().equals(shortName)) {
 				if (extClsInfo.isInner()) {
-					String parent = useClassInternal(useCls, extClsInfo.getParentClass().getAlias());
-					return parent + "." + shortName;
+					String parent = useClassInternal(useCls, extClsInfo.getParentClass());
+					return parent + '.' + shortName;
 				} else {
 					return fullName;
 				}
@@ -523,15 +563,35 @@ public class ClassGen {
 		return shortName;
 	}
 
+	private String expandInnerClassName(ClassInfo useCls, ClassInfo extClsInfo) {
+		List<ClassInfo> clsList = new ArrayList<>();
+		clsList.add(extClsInfo);
+		ClassInfo parentCls = extClsInfo.getParentClass();
+		boolean addImport = true;
+		while (parentCls != null) {
+			if (parentCls == useCls || isClassInnerFor(useCls, parentCls)) {
+				addImport = false;
+				break;
+			}
+			clsList.add(parentCls);
+			parentCls = parentCls.getParentClass();
+		}
+		Collections.reverse(clsList);
+		if (addImport) {
+			addImport(clsList.get(0));
+		}
+		return Utils.listToString(clsList, ".", ClassInfo::getAliasShortName);
+	}
+
 	private void addImport(ClassInfo classInfo) {
 		if (parentGen != null) {
-			parentGen.addImport(classInfo.getAlias());
+			parentGen.addImport(classInfo);
 		} else {
 			imports.add(classInfo);
 		}
 	}
 
-	private Set<ClassInfo> getImports() {
+	public Set<ClassInfo> getImports() {
 		if (parentGen != null) {
 			return parentGen.getImports();
 		} else {
@@ -552,7 +612,7 @@ public class ClassGen {
 	private static boolean isClassInnerFor(ClassInfo inner, ClassInfo parent) {
 		if (inner.isInner()) {
 			ClassInfo p = inner.getParentClass();
-			return p.equals(parent) || isClassInnerFor(p, parent);
+			return Objects.equals(p, parent) || isClassInnerFor(p, parent);
 		}
 		return false;
 	}
@@ -561,15 +621,15 @@ public class ClassGen {
 		if (useCls == null) {
 			return false;
 		}
-		String shortName = searchCls.getShortName();
-		if (useCls.getShortName().equals(shortName)) {
+		String shortName = searchCls.getAliasShortName();
+		if (useCls.getAliasShortName().equals(shortName)) {
 			return true;
 		}
 		ClassNode classNode = dex.resolveClass(useCls);
 		if (classNode != null) {
 			for (ClassNode inner : classNode.getInnerClasses()) {
 				if (inner.getShortName().equals(shortName)
-						&& !inner.getAlias().equals(searchCls)) {
+						&& !inner.getFullName().equals(searchCls.getAliasFullName())) {
 					return true;
 				}
 			}
@@ -577,18 +637,10 @@ public class ClassGen {
 		return searchCollision(dex, useCls.getParentClass(), searchCls);
 	}
 
-	private void insertSourceFileInfo(CodeWriter code, AttrNode node) {
-		SourceFileAttr sourceFileAttr = node.get(AType.SOURCE_FILE);
-		if (sourceFileAttr != null) {
-			code.startLine("/* compiled from: ").add(sourceFileAttr.getFileName()).add(" */");
-		}
-	}
-
 	private void insertRenameInfo(CodeWriter code, ClassNode cls) {
 		ClassInfo classInfo = cls.getClassInfo();
-		if (classInfo.isRenamed()
-				&& !cls.getShortName().equals(cls.getAlias().getShortName())) {
-			code.startLine("/* renamed from: ").add(classInfo.getFullName()).add(" */");
+		if (classInfo.hasAlias()) {
+			CodeGenUtils.addRenamedComment(code, cls, classInfo.getType().getObject());
 		}
 	}
 

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

@@ -1,25 +1,61 @@
 package jadx.core.codegen;
 
-import jadx.api.IJadxArgs;
+import java.util.concurrent.Callable;
+
+import jadx.api.ICodeInfo;
+import jadx.api.JadxArgs;
+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 CodeWriter.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 {
+	private static ICodeInfo generateJavaCode(ClassNode cls, JadxArgs args) {
 		ClassGen clsGen = new ClassGen(cls, args);
-		CodeWriter clsCode = clsGen.makeClass();
-		clsCode.finish();
-		cls.setCode(clsCode);
-		return false;
+		return wrapCodeGen(cls, clsGen::makeClass);
 	}
 
+	private static ICodeInfo generateJson(ClassNode cls) {
+		JsonCodeGen codeGen = new JsonCodeGen(cls);
+		String clsJson = wrapCodeGen(cls, codeGen::process);
+		return new CodeWriter(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,14 +1,9 @@
 package jadx.core.codegen;
 
-import jadx.api.CodePosition;
-import jadx.core.dex.attributes.nodes.LineAttrNode;
-import jadx.core.utils.files.FileUtils;
-
 import java.io.File;
 import java.io.PrintWriter;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.Map;
 import java.util.TreeMap;
 
@@ -16,26 +11,33 @@ import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static jadx.core.utils.files.FileUtils.close;
+import jadx.api.CodePosition;
+import jadx.api.ICodeInfo;
+import jadx.core.dex.attributes.nodes.LineAttrNode;
+import jadx.core.utils.StringUtils;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.utils.files.ZipSecurity;
 
-public class CodeWriter {
+public class CodeWriter implements ICodeInfo {
 	private static final Logger LOG = LoggerFactory.getLogger(CodeWriter.class);
 
 	public static final String NL = System.getProperty("line.separator");
-	public static final String INDENT = "    ";
+	public static final String INDENT_STR = "    ";
 
 	private static final boolean ADD_LINE_NUMBERS = false;
 
 	private static final String[] INDENT_CACHE = {
 			"",
-			INDENT,
-			INDENT + INDENT,
-			INDENT + INDENT + INDENT,
-			INDENT + INDENT + INDENT + INDENT,
-			INDENT + INDENT + INDENT + INDENT + INDENT,
+			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,
 	};
 
-	private StringBuilder buf = new StringBuilder();
+	public static final CodeWriter EMPTY = new CodeWriter().finish();
+
+	private StringBuilder buf;
 	@Nullable
 	private String code;
 	private String indentStr;
@@ -47,13 +49,21 @@ public class CodeWriter {
 	private Map<Integer, Integer> lineMap = Collections.emptyMap();
 
 	public CodeWriter() {
+		this.buf = new StringBuilder();
 		this.indent = 0;
 		this.indentStr = "";
 		if (ADD_LINE_NUMBERS) {
-			incIndent(2);
+			incIndent(3);
+			add(indentStr);
 		}
 	}
 
+	// create filled instance (just string wrapper)
+	public CodeWriter(String code) {
+		this.buf = null;
+		this.code = code;
+	}
+
 	public CodeWriter startLine() {
 		addLine();
 		addLineIndent();
@@ -94,6 +104,17 @@ public class CodeWriter {
 		return this;
 	}
 
+	public CodeWriter 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;
+	}
+
 	public CodeWriter add(String str) {
 		buf.append(str);
 		offset += str.length();
@@ -127,7 +148,7 @@ public class CodeWriter {
 	}
 
 	public CodeWriter addIndent() {
-		add(INDENT);
+		add(INDENT_STR);
 		return this;
 	}
 
@@ -148,9 +169,9 @@ public class CodeWriter {
 		if (curIndent < INDENT_CACHE.length) {
 			this.indentStr = INDENT_CACHE[curIndent];
 		} else {
-			StringBuilder s = new StringBuilder(curIndent * INDENT.length());
+			StringBuilder s = new StringBuilder(curIndent * INDENT_STR.length());
 			for (int i = 0; i < curIndent; i++) {
-				s.append(INDENT);
+				s.append(INDENT_STR);
 			}
 			this.indentStr = s.toString();
 		}
@@ -182,6 +203,11 @@ public class CodeWriter {
 		return indent;
 	}
 
+	public void setIndent(int indent) {
+		this.indent = indent;
+		updateIndent();
+	}
+
 	public int getLine() {
 		return line;
 	}
@@ -207,13 +233,18 @@ public class CodeWriter {
 		attachAnnotation(obj, new CodePosition(line, offset + 1));
 	}
 
+	public void attachLineAnnotation(Object obj) {
+		attachAnnotation(obj, new CodePosition(line, 0));
+	}
+
 	private Object attachAnnotation(Object obj, CodePosition pos) {
 		if (annotations.isEmpty()) {
-			annotations = new HashMap<CodePosition, Object>();
+			annotations = new HashMap<>();
 		}
 		return annotations.put(pos, obj);
 	}
 
+	@Override
 	public Map<CodePosition, Object> getAnnotations() {
 		return annotations;
 	}
@@ -227,36 +258,38 @@ public class CodeWriter {
 
 	private void attachSourceLine(int decompiledLine, int sourceLine) {
 		if (lineMap.isEmpty()) {
-			lineMap = new TreeMap<Integer, Integer>();
+			lineMap = new TreeMap<>();
 		}
 		lineMap.put(decompiledLine, sourceLine);
 	}
 
+	@Override
 	public Map<Integer, Integer> getLineMapping() {
 		return lineMap;
 	}
 
-	public void finish() {
+	public CodeWriter finish() {
 		removeFirstEmptyLine();
 		buf.trimToSize();
 		code = buf.toString();
 		buf = null;
 
-		Iterator<Map.Entry<CodePosition, Object>> it = annotations.entrySet().iterator();
-		while (it.hasNext()) {
-			Map.Entry<CodePosition, Object> entry = it.next();
+		annotations.entrySet().removeIf(entry -> {
 			Object v = entry.getValue();
 			if (v instanceof DefinitionWrapper) {
 				LineAttrNode l = ((DefinitionWrapper) v).getNode();
 				l.setDecompiledLine(entry.getKey().getLine());
-				it.remove();
+				return true;
 			}
-		}
+			return false;
+		});
+		return this;
 	}
 
 	private void removeFirstEmptyLine() {
-		if (buf.indexOf(NL) == 0) {
-			buf.delete(0, NL.length());
+		int len = NL.length();
+		if (buf.length() > len && buf.substring(0, len).equals(NL)) {
+			buf.delete(0, len);
 		}
 	}
 
@@ -264,7 +297,11 @@ public class CodeWriter {
 		return buf.length();
 	}
 
+	@Override
 	public String getCodeStr() {
+		if (code == null) {
+			throw new NullPointerException("Code not set");
+		}
 		return code;
 	}
 
@@ -274,10 +311,16 @@ public class CodeWriter {
 	}
 
 	public void save(File dir, String subDir, String fileName) {
+		if (!ZipSecurity.isValidZipEntryName(subDir) || !ZipSecurity.isValidZipEntryName(fileName)) {
+			return;
+		}
 		save(dir, new File(subDir, fileName).getPath());
 	}
 
 	public void save(File dir, String fileName) {
+		if (!ZipSecurity.isValidZipEntryName(fileName)) {
+			return;
+		}
 		save(new File(dir, fileName));
 	}
 
@@ -286,15 +329,10 @@ public class CodeWriter {
 			finish();
 		}
 		File outFile = FileUtils.prepareFile(file);
-		PrintWriter out = null;
-		try {
-			out = new PrintWriter(outFile, "UTF-8");
+		try (PrintWriter out = new PrintWriter(outFile, "UTF-8")) {
 			out.println(code);
 		} catch (Exception e) {
 			LOG.error("Save file error", e);
-		} finally {
-			close(out);
 		}
 	}
-
 }

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

@@ -1,5 +1,10 @@
 package jadx.core.codegen;
 
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+
+import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.instructions.ArithNode;
 import jadx.core.dex.instructions.IfOp;
 import jadx.core.dex.instructions.InsnType;
@@ -15,18 +20,10 @@ import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.exceptions.CodegenException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.Queue;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 public class ConditionGen extends InsnGen {
-	private static final Logger LOG = LoggerFactory.getLogger(ConditionGen.class);
 
 	private static class CondStack {
-		private final Queue<IfCondition> stack = new LinkedList<IfCondition>();
+		private final Queue<IfCondition> stack = new LinkedList<>();
 
 		public Queue<IfCondition> getStack() {
 			return stack;
@@ -126,7 +123,7 @@ public class ConditionGen extends InsnGen {
 				wrap(code, firstArg);
 				return;
 			}
-			LOG.warn(ErrorsCounter.formatErrorMsg(mth, "Unsupported boolean condition " + op.getSymbol()));
+			ErrorsCounter.methodWarn(mth, "Unsupported boolean condition " + op.getSymbol());
 		}
 
 		addArg(code, firstArg, isArgWrapNeeded(firstArg));
@@ -159,7 +156,7 @@ public class ConditionGen extends InsnGen {
 	}
 
 	private boolean isWrapNeeded(IfCondition condition) {
-		if (condition.isCompare()) {
+		if (condition.isCompare() || condition.contains(AFlag.DONT_WRAP)) {
 			return false;
 		}
 		return condition.getMode() != Mode.NOT;
@@ -179,6 +176,9 @@ public class ConditionGen extends InsnGen {
 				case DIV:
 				case REM:
 					return false;
+
+				default:
+					return true;
 			}
 		} else {
 			switch (insnType) {
@@ -189,10 +189,10 @@ public class ConditionGen extends InsnGen {
 				case CONST:
 				case ARRAY_LENGTH:
 					return false;
+
 				default:
 					return true;
 			}
 		}
-		return true;
 	}
 }

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

@@ -1,15 +1,29 @@
 package jadx.core.codegen;
 
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.core.Consts;
+import jadx.core.deobf.NameMapper;
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.FieldReplaceAttr;
 import jadx.core.dex.attributes.nodes.LoopLabelAttr;
 import jadx.core.dex.attributes.nodes.MethodInlineAttr;
+import jadx.core.dex.attributes.nodes.SkipMethodArgsAttr;
 import jadx.core.dex.info.ClassInfo;
 import jadx.core.dex.info.FieldInfo;
 import jadx.core.dex.info.MethodInfo;
 import jadx.core.dex.instructions.ArithNode;
 import jadx.core.dex.instructions.ArithOp;
+import jadx.core.dex.instructions.CallMthInterface;
 import jadx.core.dex.instructions.ConstClassNode;
 import jadx.core.dex.instructions.ConstStringNode;
 import jadx.core.dex.instructions.FillArrayNode;
@@ -23,12 +37,14 @@ import jadx.core.dex.instructions.InvokeType;
 import jadx.core.dex.instructions.NewArrayNode;
 import jadx.core.dex.instructions.SwitchNode;
 import jadx.core.dex.instructions.args.ArgType;
-import jadx.core.dex.instructions.args.FieldArg;
+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.LiteralArg;
 import jadx.core.dex.instructions.args.Named;
+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.instructions.mods.TernaryInsn;
 import jadx.core.dex.nodes.ClassNode;
@@ -36,22 +52,11 @@ import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.InsnNode;
 import jadx.core.dex.nodes.MethodNode;
 import jadx.core.dex.nodes.RootNode;
-import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.RegionUtils;
+import jadx.core.utils.TypeUtils;
 import jadx.core.utils.exceptions.CodegenException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.EnumSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
-
-import org.jetbrains.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import static jadx.core.utils.android.AndroidResourcesUtils.handleAppResField;
 
 public class InsnGen {
@@ -61,6 +66,7 @@ public class InsnGen {
 	protected final MethodNode mth;
 	protected final RootNode root;
 	protected final boolean fallback;
+	protected final boolean attachInsns;
 
 	protected enum Flags {
 		BODY_ONLY,
@@ -71,8 +77,9 @@ public class InsnGen {
 	public InsnGen(MethodGen mgen, boolean fallback) {
 		this.mgen = mgen;
 		this.mth = mgen.getMethodNode();
-		this.root = mth.dex().root();
+		this.root = mth.root();
 		this.fallback = fallback;
+		this.attachInsns = root.getArgs().isJsonOutput();
 	}
 
 	private boolean isFallback() {
@@ -97,22 +104,26 @@ public class InsnGen {
 		} else if (arg.isLiteral()) {
 			code.add(lit((LiteralArg) arg));
 		} else if (arg.isInsnWrap()) {
-			Flags flag = wrap ? Flags.BODY_ONLY : Flags.BODY_ONLY_NOWRAP;
-			makeInsn(((InsnWrapArg) arg).getWrapInsn(), code, flag);
+			addWrappedArg(code, (InsnWrapArg) arg, wrap);
 		} else if (arg.isNamed()) {
 			code.add(((Named) arg).getName());
-		} else if (arg.isField()) {
-			FieldArg f = (FieldArg) arg;
-			if (f.isStatic()) {
-				staticField(code, f.getField());
-			} else {
-				instanceField(code, f.getField(), f.getInstanceArg());
-			}
 		} else {
 			throw new CodegenException("Unknown arg type " + arg);
 		}
 	}
 
+	private void addWrappedArg(CodeWriter code, InsnWrapArg arg, boolean wrap) throws CodegenException {
+		InsnNode wrapInsn = arg.getWrapInsn();
+		if (wrapInsn.contains(AFlag.FORCE_ASSIGN_INLINE)) {
+			code.add('(');
+			makeInsn(wrapInsn, code, Flags.INLINE);
+			code.add(')');
+		} else {
+			Flags flags = wrap ? Flags.BODY_ONLY : Flags.BODY_ONLY_NOWRAP;
+			makeInsn(wrapInsn, code, flags);
+		}
+	}
+
 	public void assignVar(CodeWriter code, InsnNode insn) throws CodegenException {
 		RegisterArg arg = insn.getResult();
 		if (insn.contains(AFlag.DECLARE_VAR)) {
@@ -123,27 +134,25 @@ public class InsnGen {
 	}
 
 	public void declareVar(CodeWriter code, RegisterArg arg) {
-		if (arg.getSVar().contains(AFlag.FINAL)) {
+		declareVar(code, arg.getSVar().getCodeVar());
+	}
+
+	public void declareVar(CodeWriter code, CodeVar codeVar) {
+		if (codeVar.isFinal()) {
 			code.add("final ");
 		}
-		useType(code, arg.getType());
+		useType(code, codeVar.getType());
 		code.add(' ');
-		code.add(mgen.getNameGen().assignArg(arg));
+		code.add(mgen.getNameGen().assignArg(codeVar));
 	}
 
 	private String lit(LiteralArg arg) {
-		return TypeGen.literalToString(arg.getLiteral(), arg.getType(), mth);
+		return TypeGen.literalToString(arg, mth, fallback);
 	}
 
 	private void instanceField(CodeWriter code, FieldInfo field, InsnArg arg) throws CodegenException {
 		ClassNode pCls = mth.getParentClass();
-		FieldNode fieldNode = pCls.searchField(field);
-		while (fieldNode == null
-				&& pCls.getParentClass() != pCls
-				&& pCls.getParentClass() != null) {
-			pCls = pCls.getParentClass();
-			fieldNode = pCls.searchField(field);
-		}
+		FieldNode fieldNode = pCls.dex().root().deepResolveField(field);
 		if (fieldNode != null) {
 			FieldReplaceAttr replace = fieldNode.get(AType.FIELD_REPLACE);
 			if (replace != null) {
@@ -163,11 +172,16 @@ public class InsnGen {
 		if (fieldNode != null) {
 			code.attachAnnotation(fieldNode);
 		}
-		code.add(field.getAlias());
+		if (fieldNode == null) {
+			code.add(field.getAlias());
+		} else {
+			code.add(fieldNode.getAlias());
+		}
 	}
 
 	public static void makeStaticFieldAccess(CodeWriter code, FieldInfo field, ClassGen clsGen) {
 		ClassInfo declClass = field.getDeclClass();
+		// TODO
 		boolean fieldFromThisClass = clsGen.getClassNode().getClassInfo().equals(declClass);
 		if (!fieldFromThisClass) {
 			// Android specific resources class handler
@@ -176,11 +190,15 @@ public class InsnGen {
 			}
 			code.add('.');
 		}
-		FieldNode fieldNode = clsGen.getClassNode().dex().resolveField(field);
+		FieldNode fieldNode = clsGen.getClassNode().dex().root().deepResolveField(field);
 		if (fieldNode != null) {
 			code.attachAnnotation(fieldNode);
 		}
-		code.add(field.getAlias());
+		if (fieldNode == null) {
+			code.add(field.getAlias());
+		} else {
+			code.add(fieldNode.getAlias());
+		}
 	}
 
 	protected void staticField(CodeWriter code, FieldInfo field) {
@@ -199,33 +217,44 @@ public class InsnGen {
 		mgen.getClassGen().useType(code, type);
 	}
 
-	public boolean makeInsn(InsnNode insn, CodeWriter code) throws CodegenException {
-		return makeInsn(insn, code, null);
+	public void makeInsn(InsnNode insn, CodeWriter code) throws CodegenException {
+		makeInsn(insn, code, null);
 	}
 
-	protected boolean makeInsn(InsnNode insn, CodeWriter code, Flags flag) throws CodegenException {
+	private static final Set<Flags> EMPTY_FLAGS = EnumSet.noneOf(Flags.class);
+	private static final Set<Flags> BODY_ONLY_FLAG = EnumSet.of(Flags.BODY_ONLY);
+	private static final Set<Flags> BODY_ONLY_NOWRAP_FLAGS = EnumSet.of(Flags.BODY_ONLY_NOWRAP);
+
+	protected void makeInsn(InsnNode insn, CodeWriter code, Flags flag) throws CodegenException {
 		try {
-			Set<Flags> state = EnumSet.noneOf(Flags.class);
 			if (flag == Flags.BODY_ONLY || flag == Flags.BODY_ONLY_NOWRAP) {
-				state.add(flag);
-				makeInsnBody(code, insn, state);
+				makeInsnBody(code, insn, flag == Flags.BODY_ONLY ? BODY_ONLY_FLAG : BODY_ONLY_NOWRAP_FLAGS);
 			} else {
 				if (flag != Flags.INLINE) {
 					code.startLineWithNum(insn.getSourceLine());
+					if (attachInsns) {
+						code.attachLineAnnotation(insn);
+					}
+					if (insn.contains(AFlag.COMMENT_OUT)) {
+						code.add("// ");
+					}
 				}
-				if (insn.getResult() != null && !insn.contains(AFlag.ARITH_ONEARG)) {
-					assignVar(code, insn);
-					code.add(" = ");
+				RegisterArg resArg = insn.getResult();
+				if (resArg != null) {
+					SSAVar var = resArg.getSVar();
+					if (var == null || var.getUseCount() != 0 || insn.getType() != InsnType.CONSTRUCTOR) {
+						assignVar(code, insn);
+						code.add(" = ");
+					}
 				}
-				makeInsnBody(code, insn, state);
+				makeInsnBody(code, insn, EMPTY_FLAGS);
 				if (flag != Flags.INLINE) {
 					code.add(';');
 				}
 			}
-		} catch (Throwable th) {
-			throw new CodegenException(mth, "Error generate insn: " + insn, th);
+		} catch (Exception e) {
+			throw new CodegenException(mth, "Error generate insn: " + insn, e);
 		}
-		return true;
 	}
 
 	private void makeInsnBody(CodeWriter code, InsnNode insn, Set<Flags> state) throws CodegenException {
@@ -270,18 +299,14 @@ public class InsnGen {
 				makeArith((ArithNode) insn, code, state);
 				break;
 
-			case NEG: {
-				boolean wrap = state.contains(Flags.BODY_ONLY);
-				if (wrap) {
-					code.add('(');
-				}
-				code.add('-');
-				addArg(code, insn.getArg(0));
-				if (wrap) {
-					code.add(')');
-				}
+			case NEG:
+				oneArgInsn(code, insn, state, '-');
+				break;
+
+			case NOT:
+				char op = insn.getArg(0).getType() == ArgType.BOOLEAN ? '!' : '~';
+				oneArgInsn(code, insn, state, op);
 				break;
-			}
 
 			case RETURN:
 				if (insn.getArgsCount() != 0) {
@@ -366,6 +391,17 @@ public class InsnGen {
 				filledNewArray((FilledNewArrayNode) insn, code);
 				break;
 
+			case FILL_ARRAY:
+				FillArrayNode arrayNode = (FillArrayNode) insn;
+				if (fallback) {
+					String arrStr = arrayNode.dataToString();
+					addArg(code, insn.getArg(0));
+					code.add(" = {").add(arrStr.substring(1, arrStr.length() - 1)).add("} // fill-array");
+				} else {
+					fillArray(code, arrayNode);
+				}
+				break;
+
 			case AGET:
 				addArg(code, insn.getArg(0));
 				code.add('[');
@@ -409,7 +445,7 @@ public class InsnGen {
 				if (wrap) {
 					code.add('(');
 				}
-				for (Iterator<InsnArg> it = insn.getArguments().iterator(); it.hasNext(); ) {
+				for (Iterator<InsnArg> it = insn.getArguments().iterator(); it.hasNext();) {
 					addArg(code, it.next());
 					if (it.hasNext()) {
 						code.add(" + ");
@@ -484,40 +520,20 @@ public class InsnGen {
 				code.startLine('}');
 				break;
 
-			case FILL_ARRAY:
-				fallbackOnlyInsn(insn);
-				FillArrayNode arrayNode = (FillArrayNode) insn;
-				Object data = arrayNode.getData();
-				String arrStr;
-				if (data instanceof int[]) {
-					arrStr = Arrays.toString((int[]) data);
-				} else if (data instanceof short[]) {
-					arrStr = Arrays.toString((short[]) data);
-				} else if (data instanceof byte[]) {
-					arrStr = Arrays.toString((byte[]) data);
-				} else if (data instanceof long[]) {
-					arrStr = Arrays.toString((long[]) data);
-				} else {
-					arrStr = "?";
-				}
-				code.add('{').add(arrStr.substring(1, arrStr.length() - 1)).add('}');
-				break;
-
 			case NEW_INSTANCE:
 				// only fallback - make new instance in constructor invoke
 				fallbackOnlyInsn(insn);
-				code.add("new ").add(insn.getResult().getType().toString());
+				code.add("new ").add(insn.getResult().getInitType().toString());
 				break;
 
 			case PHI:
-			case MERGE:
 				fallbackOnlyInsn(insn);
-				code.add(insn.getType().toString()).add("(");
+				code.add(insn.getType().toString()).add('(');
 				for (InsnArg insnArg : insn.getArguments()) {
 					addArg(code, insnArg);
 					code.add(' ');
 				}
-				code.add(")");
+				code.add(')');
 				break;
 
 			default:
@@ -525,15 +541,53 @@ public class InsnGen {
 		}
 	}
 
+	/**
+	 * In most cases must be combined with new array instructions.
+	 * Use one by one array fill (can be replaced with System.arrayCopy)
+	 */
+	private void fillArray(CodeWriter code, FillArrayNode arrayNode) throws CodegenException {
+		code.add("// fill-array-data instruction");
+		code.startLine();
+		List<LiteralArg> args = arrayNode.getLiteralArgs(arrayNode.getElementType());
+		InsnArg arrArg = arrayNode.getArg(0);
+		int len = args.size();
+		for (int i = 0; i < len; i++) {
+			if (i != 0) {
+				code.add(';');
+				code.startLine();
+			}
+			addArg(code, arrArg);
+			code.add('[').add(Integer.toString(i)).add("] = ").add(lit(args.get(i)));
+		}
+	}
+
+	private void oneArgInsn(CodeWriter code, InsnNode insn, Set<Flags> state, char op) throws CodegenException {
+		boolean wrap = state.contains(Flags.BODY_ONLY);
+		if (wrap) {
+			code.add('(');
+		}
+		code.add(op);
+		addArg(code, insn.getArg(0));
+		if (wrap) {
+			code.add(')');
+		}
+	}
+
 	private void fallbackOnlyInsn(InsnNode insn) throws CodegenException {
 		if (!fallback) {
-			throw new CodegenException(insn.getType() + " can be used only in fallback mode");
+			String msg = insn.getType() + " instruction can be used only in fallback mode";
+			CodegenException e = new CodegenException(msg);
+			mth.addError(msg, e);
+			mth.getParentClass().getTopParentClass().add(AFlag.RESTART_CODEGEN);
+			throw e;
 		}
 	}
 
 	private void filledNewArray(FilledNewArrayNode insn, CodeWriter code) throws CodegenException {
-		code.add("new ");
-		useType(code, insn.getArrayType());
+		if (!insn.contains(AFlag.DECLARE_VAR)) {
+			code.add("new ");
+			useType(code, insn.getArrayType());
+		}
 		code.add('{');
 		int c = insn.getArgsCount();
 		for (int i = 0; i < c; i++) {
@@ -548,8 +602,9 @@ public class InsnGen {
 	private void makeConstructor(ConstructorInsn insn, CodeWriter code)
 			throws CodegenException {
 		ClassNode cls = mth.dex().resolveClass(insn.getClassType());
-		if (cls != null && cls.contains(AFlag.ANONYMOUS_CLASS) && !fallback) {
-			inlineAnonymousConstr(code, cls, insn);
+		if (cls != null && cls.isAnonymous() && !fallback) {
+			cls.ensureProcessed();
+			inlineAnonymousConstructor(code, cls, insn);
 			return;
 		}
 		if (insn.isSelf()) {
@@ -562,33 +617,53 @@ public class InsnGen {
 		} else {
 			code.add("new ");
 			useClass(code, insn.getClassType());
+			ArgType argType = insn.getResult().getSVar().getCodeVar().getType();
+			boolean genericCls = cls == null || !cls.getGenerics().isEmpty();
+			if (argType != null
+					&& argType.getGenericTypes() != null
+					&& genericCls) {
+				code.add('<');
+				if (insn.contains(AFlag.EXPLICIT_GENERICS)) {
+					boolean first = true;
+					for (ArgType type : argType.getGenericTypes()) {
+						if (!first) {
+							code.add(',');
+						}
+						mgen.getClassGen().useType(code, type);
+						first = false;
+					}
+				}
+				code.add('>');
+			}
 		}
 		MethodNode callMth = mth.dex().resolveMethod(insn.getCallMth());
 		generateMethodArguments(code, insn, 0, callMth);
 	}
 
-	private void inlineAnonymousConstr(CodeWriter code, ClassNode cls, ConstructorInsn insn) throws CodegenException {
-		// anonymous class construction
-		if (cls.contains(AFlag.DONT_GENERATE)) {
-			code.add("/* anonymous class already generated */");
-			ErrorsCounter.methodError(mth, "Anonymous class already generated: " + cls);
-			return;
+	private void inlineAnonymousConstructor(CodeWriter code, ClassNode cls, ConstructorInsn insn) throws CodegenException {
+		if (this.mth.getParentClass() == cls) {
+			cls.remove(AFlag.ANONYMOUS_CLASS);
+			cls.remove(AFlag.DONT_GENERATE);
+			mth.getParentClass().getTopParentClass().add(AFlag.RESTART_CODEGEN);
+			throw new CodegenException("Anonymous inner class unlimited recursion detected."
+					+ " Convert class to inner: " + cls.getClassInfo().getFullName());
 		}
+
+		cls.add(AFlag.DONT_GENERATE);
 		ArgType parent;
 		if (cls.getInterfaces().size() == 1) {
 			parent = cls.getInterfaces().get(0);
 		} else {
 			parent = cls.getSuperClass();
 		}
-		cls.add(AFlag.DONT_GENERATE);
-		MethodNode defCtr = cls.getDefaultConstructor();
-		if (defCtr != null) {
-			if (RegionUtils.notEmpty(defCtr.getRegion())) {
-				defCtr.add(AFlag.ANONYMOUS_CONSTRUCTOR);
-			} else {
-				defCtr.add(AFlag.DONT_GENERATE);
+		// hide empty anonymous constructors
+		for (MethodNode ctor : cls.getMethods()) {
+			if (ctor.contains(AFlag.ANONYMOUS_CONSTRUCTOR)
+					&& RegionUtils.isEmpty(ctor.getRegion())) {
+				ctor.add(AFlag.DONT_GENERATE);
 			}
 		}
+
 		code.add("new ");
 		if (parent == null) {
 			code.add("Object");
@@ -605,12 +680,9 @@ public class InsnGen {
 		MethodInfo callMth = insn.getCallMth();
 
 		// inline method
-		MethodNode callMthNode = mth.dex().deepResolveMethod(callMth);
-		if (callMthNode != null) {
-			if (inlineMethod(callMthNode, insn, code)) {
-				return;
-			}
-			callMth = callMthNode.getMethodInfo();
+		MethodNode callMthNode = mth.root().deepResolveMethod(callMth);
+		if (callMthNode != null && inlineMethod(callMthNode, insn, code)) {
+			return;
 		}
 
 		int k = 0;
@@ -628,13 +700,18 @@ public class InsnGen {
 				break;
 
 			case SUPER:
+				ClassInfo superCallCls = getClassForSuperCall(code, callMth);
+				if (superCallCls != null) {
+					useClass(code, superCallCls);
+					code.add('.');
+				}
 				// use 'super' instead 'this' in 0 arg
 				code.add("super").add('.');
 				k++;
 				break;
 
 			case STATIC:
-				ClassInfo insnCls = mth.getParentClass().getAlias();
+				ClassInfo insnCls = mth.getParentClass().getClassInfo();
 				ClassInfo declClass = callMth.getDeclClass();
 				if (!insnCls.equals(declClass)) {
 					useClass(code, declClass);
@@ -644,11 +721,43 @@ public class InsnGen {
 		}
 		if (callMthNode != null) {
 			code.attachAnnotation(callMthNode);
+			code.add(callMthNode.getAlias());
+		} else {
+			code.add(callMth.getAlias());
 		}
-		code.add(callMth.getAlias());
 		generateMethodArguments(code, insn, k, callMthNode);
 	}
 
+	@Nullable
+	private ClassInfo getClassForSuperCall(CodeWriter code, MethodInfo callMth) {
+		ClassNode useCls = mth.getParentClass();
+		ClassInfo insnCls = useCls.getClassInfo();
+		ClassInfo declClass = callMth.getDeclClass();
+		if (insnCls.equals(declClass)) {
+			return null;
+		}
+		ClassNode topClass = useCls.getTopParentClass();
+		if (topClass.getClassInfo().equals(declClass)) {
+			return declClass;
+		}
+		// search call class
+		ClassNode nextParent = useCls;
+		do {
+			ClassInfo nextClsInfo = nextParent.getClassInfo();
+			if (nextClsInfo.equals(declClass)
+					|| ArgType.isInstanceOf(mth.root(), nextClsInfo.getType(), declClass.getType())) {
+				if (nextParent == useCls) {
+					return null;
+				}
+				return nextClsInfo;
+			}
+			nextParent = nextParent.getParentClass();
+		} while (nextParent != null && nextParent != topClass);
+
+		// search failed, just return parent class
+		return useCls.getParentClass().getClassInfo();
+	}
+
 	void generateMethodArguments(CodeWriter code, InsnNode insn, int startArgNum,
 			@Nullable MethodNode callMth) throws CodegenException {
 		int k = startArgNum;
@@ -665,14 +774,13 @@ public class InsnGen {
 				if (arg.contains(AFlag.SKIP_ARG)) {
 					continue;
 				}
-				RegisterArg callArg = getCallMthArg(callMth, i - startArgNum);
-				if (callArg != null && callArg.contains(AFlag.SKIP_ARG)) {
+				if (SkipMethodArgsAttr.isSkip(callMth, i - startArgNum)) {
 					continue;
 				}
 				if (!firstArg) {
 					code.add(", ");
 				}
-				boolean cast = overloaded && processOverloadedArg(code, callMth, arg, i - startArgNum);
+				boolean cast = addArgCast(code, insn, callMth, arg, i - startArgNum, overloaded);
 				if (!cast && i == argsCount - 1 && processVarArg(code, callMth, arg)) {
 					continue;
 				}
@@ -683,31 +791,68 @@ public class InsnGen {
 		code.add(')');
 	}
 
-	private static RegisterArg getCallMthArg(@Nullable MethodNode callMth, int num) {
-		if (callMth == null) {
-			return null;
-		}
-		List<RegisterArg> args = callMth.getArguments(false);
-		if (args != null && num < args.size()) {
-			return args.get(num);
-		}
-		return null;
-	}
-
 	/**
-	 * Add additional cast for overloaded method argument.
+	 * Add additional cast for method argument.
 	 */
-	private boolean processOverloadedArg(CodeWriter code, MethodNode callMth, InsnArg arg, int origPos) {
-		ArgType origType = callMth.getMethodInfo().getArgumentsTypes().get(origPos);
-		if (!arg.getType().equals(origType)) {
+	private boolean addArgCast(CodeWriter code, InsnNode insn, @Nullable MethodNode callMth,
+			InsnArg arg, int origPos, boolean overloaded) {
+		ArgType castType = null;
+		if (callMth != null) {
+			List<ArgType> argTypes = callMth.getArgTypes();
+			ArgType origType = argTypes.get(origPos);
+			if (origType.isGenericType() && !callMth.getParentClass().equals(mth.getParentClass())) {
+				// cancel cast
+				return false;
+			}
+			if (insn instanceof CallMthInterface && origType.containsGenericType()) {
+				ArgType clsType;
+				CallMthInterface mthCall = (CallMthInterface) insn;
+				RegisterArg instanceArg = mthCall.getInstanceArg();
+				if (instanceArg != null) {
+					clsType = instanceArg.getType();
+				} else {
+					clsType = mthCall.getCallMth().getDeclClass().getType();
+				}
+				ArgType replacedType = TypeUtils.replaceClassGenerics(root, clsType, origType);
+				if (replacedType != null) {
+					castType = replacedType;
+				}
+				if (castType == null) {
+					ArgType invReplType = TypeUtils.replaceMethodGenerics(root, insn, origType);
+					if (invReplType != null) {
+						castType = invReplType;
+					}
+				}
+			}
+			if (castType == null) {
+				castType = origType;
+			}
+		} else {
+			castType = arg.getType();
+		}
+		// TODO: check castType for left type variables
+
+		if (isCastNeeded(arg, castType, overloaded)) {
 			code.add('(');
-			useType(code, origType);
+			useType(code, castType);
 			code.add(") ");
 			return true;
 		}
 		return false;
 	}
 
+	private boolean isCastNeeded(InsnArg arg, ArgType origType, boolean overloaded) {
+		ArgType argType = arg.getType();
+		if (arg.isLiteral() && ((LiteralArg) arg).getLiteral() == 0
+				&& (argType.isObject() || argType.isArray())) {
+			return true;
+		}
+		if (argType.equals(origType)) {
+			return false;
+		}
+		return overloaded;
+	}
+
 	/**
 	 * Expand varArgs from filled array.
 	 */
@@ -739,20 +884,29 @@ public class InsnGen {
 			return false;
 		}
 		InsnNode inl = mia.getInsn();
+		if (Consts.DEBUG) {
+			code.add("/* inline method: ").add(callMthNode.toString()).add("*/").startLine();
+		}
+		if (forceAssign(inl, insn, callMthNode)) {
+			ArgType varType = callMthNode.getReturnType();
+			useType(code, varType);
+			code.add(' ');
+			code.add(mgen.getNameGen().assignNamedArg(new NamedArg("unused", varType)));
+			code.add(" = ");
+		}
 		if (callMthNode.getMethodInfo().getArgumentsTypes().isEmpty()) {
 			makeInsn(inl, code, Flags.BODY_ONLY);
 		} else {
 			// remap args
 			InsnArg[] regs = new InsnArg[callMthNode.getRegsCount()];
-			List<RegisterArg> callArgs = callMthNode.getArguments(true);
-			for (int i = 0; i < callArgs.size(); i++) {
+			int[] regNums = mia.getArgsRegNums();
+			for (int i = 0; i < regNums.length; i++) {
 				InsnArg arg = insn.getArg(i);
-				RegisterArg callArg = callArgs.get(i);
-				regs[callArg.getRegNum()] = arg;
+				regs[regNums[i]] = arg;
 			}
 			// replace args
 			InsnNode inlCopy = inl.copy();
-			List<RegisterArg> inlArgs = new ArrayList<RegisterArg>();
+			List<RegisterArg> inlArgs = new ArrayList<>();
 			inlCopy.getRegisterArgs(inlArgs);
 			for (RegisterArg r : inlArgs) {
 				int regNum = r.getRegNum();
@@ -772,6 +926,16 @@ public class InsnGen {
 		return true;
 	}
 
+	private boolean forceAssign(InsnNode inlineInsn, InvokeNode parentInsn, MethodNode callMthNode) {
+		if (parentInsn.getResult() != null) {
+			return false;
+		}
+		if (parentInsn.contains(AFlag.WRAPPED)) {
+			return false;
+		}
+		return !callMthNode.getReturnType().equals(ArgType.VOID);
+	}
+
 	private void makeTernary(TernaryInsn insn, CodeWriter code, Set<Flags> state) throws CodegenException {
 		boolean wrap = state.contains(Flags.BODY_ONLY);
 		if (wrap) {
@@ -785,6 +949,7 @@ public class InsnGen {
 		} else {
 			condGen.wrap(code, insn.getCondition());
 			code.add(" ? ");
+			addCastIfNeeded(code, first, second);
 			addArg(code, first, false);
 			code.add(" : ");
 			addArg(code, second, false);
@@ -794,6 +959,33 @@ public class InsnGen {
 		}
 	}
 
+	private void addCastIfNeeded(CodeWriter code, InsnArg first, InsnArg second) {
+		if (first.isLiteral() && second.isLiteral()) {
+			if (first.getType() == ArgType.BYTE) {
+				long lit1 = ((LiteralArg) first).getLiteral();
+				long lit2 = ((LiteralArg) second).getLiteral();
+				if (lit1 != Byte.MAX_VALUE && lit1 != Byte.MIN_VALUE
+						&& lit2 != Byte.MAX_VALUE && lit2 != Byte.MIN_VALUE) {
+					code.add("(byte) ");
+				}
+			} else if (first.getType() == ArgType.SHORT) {
+				long lit1 = ((LiteralArg) first).getLiteral();
+				long lit2 = ((LiteralArg) second).getLiteral();
+				if (lit1 != Short.MAX_VALUE && lit1 != Short.MIN_VALUE
+						&& lit2 != Short.MAX_VALUE && lit2 != Short.MIN_VALUE) {
+					code.add("(short) ");
+				}
+			} else if (first.getType() == ArgType.CHAR) {
+				long lit1 = ((LiteralArg) first).getLiteral();
+				long lit2 = ((LiteralArg) second).getLiteral();
+				if (!NameMapper.isPrintableChar((char) (lit1))
+						&& !NameMapper.isPrintableChar((char) (lit2))) {
+					code.add("(char) ");
+				}
+			}
+		}
+	}
+
 	private void makeArith(ArithNode insn, CodeWriter code, Set<Flags> state) throws CodegenException {
 		if (insn.contains(AFlag.ARITH_ONEARG)) {
 			makeArithOneArg(insn, code);
@@ -816,19 +1008,22 @@ public class InsnGen {
 
 	private void makeArithOneArg(ArithNode insn, CodeWriter code) throws CodegenException {
 		ArithOp op = insn.getOp();
+		InsnArg resArg = insn.getArg(0);
 		InsnArg arg = insn.getArg(1);
+
 		// "++" or "--"
 		if (arg.isLiteral() && (op == ArithOp.ADD || op == ArithOp.SUB)) {
 			LiteralArg lit = (LiteralArg) arg;
-			if (lit.isInteger() && lit.getLiteral() == 1) {
-				assignVar(code, insn);
+			if (lit.getLiteral() == 1 && lit.isInteger()) {
+				addArg(code, resArg, false);
 				String opSymbol = op.getSymbol();
 				code.add(opSymbol).add(opSymbol);
 				return;
 			}
 		}
-		// +=, -= ...
-		assignVar(code, insn);
+
+		// +=, -=, ...
+		addArg(code, resArg, false);
 		code.add(' ').add(op.getSymbol()).add("= ");
 		addArg(code, arg, false);
 	}

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

@@ -1,25 +1,6 @@
 package jadx.core.codegen;
 
-import jadx.core.dex.attributes.AFlag;
-import jadx.core.dex.attributes.AType;
-import jadx.core.dex.attributes.annotations.MethodParameters;
-import jadx.core.dex.attributes.nodes.JadxErrorAttr;
-import jadx.core.dex.info.AccessInfo;
-import jadx.core.dex.instructions.InsnType;
-import jadx.core.dex.instructions.args.ArgType;
-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.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.Collections;
 import java.util.Iterator;
 import java.util.List;
 
@@ -28,6 +9,30 @@ import org.slf4j.LoggerFactory;
 
 import com.android.dx.rop.code.AccessFlags;
 
+import jadx.core.Consts;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.annotations.MethodParameters;
+import jadx.core.dex.attributes.nodes.JumpInfo;
+import jadx.core.dex.info.AccessInfo;
+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.FallbackModeVisitor;
+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.DecodeException;
+import jadx.core.utils.exceptions.JadxOverflowException;
+
 public class MethodGen {
 	private static final Logger LOG = LoggerFactory.getLogger(MethodGen.class);
 
@@ -80,13 +85,24 @@ public class MethodGen {
 		if (clsAccFlags.isAnnotation()) {
 			ai = ai.remove(AccessFlags.ACC_PUBLIC);
 		}
+
+		if (mth.getMethodInfo().hasAlias() && !ai.isConstructor()) {
+			CodeGenUtils.addRenamedComment(code, mth, mth.getName());
+		}
+		if (mth.contains(AFlag.INCONSISTENT_CODE)) {
+			code.startLine("/* Code decompiled incorrectly, please refer to instructions dump. */");
+		}
+
 		code.startLineWithNum(mth.getSourceLine());
 		code.add(ai.makeString());
+		if (Consts.DEBUG) {
+			code.add(mth.isVirtual() ? "/* virtual */ " : "/* direct */ ");
+		}
 
-		if (classGen.addGenericMap(code, mth.getGenericMap())) {
+		if (classGen.addGenericMap(code, mth.getGenerics(), false)) {
 			code.add(' ');
 		}
-		if (mth.getAccessFlags().isConstructor()) {
+		if (ai.isConstructor()) {
 			code.attachDefinition(mth);
 			code.add(classGen.getClassNode().getShortName()); // constructor
 		} else {
@@ -97,108 +113,143 @@ public class MethodGen {
 		}
 		code.add('(');
 
-		List<RegisterArg> args = mth.getArguments(false);
+		List<RegisterArg> args = mth.getArgRegs();
 		if (mth.getMethodInfo().isConstructor()
 				&& 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.addComment("JADX WARN: 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());
 		}
 		addMethodArguments(code, args);
 		code.add(')');
 
 		annotationGen.addThrows(mth, code);
+
+		// add default value if in annotation class
+		if (mth.getParentClass().getAccessFlags().isAnnotation()) {
+			Object def = annotationGen.getAnnotationDefaultValue(mth.getName());
+			if (def != null) {
+				code.add(" default ");
+				annotationGen.encodeValue(code, def);
+			}
+		}
 		return true;
 	}
 
-	private void addMethodArguments(CodeWriter argsCode, List<RegisterArg> args) {
+	private void addMethodArguments(CodeWriter code, List<RegisterArg> args) {
 		MethodParameters paramsAnnotation = mth.get(AType.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) {
+				// null for abstract or interface methods
+				var = CodeVar.fromMthArg(mthArg);
+			} else {
+				var = ssaVar.getCodeVar();
+			}
 
 			// add argument annotation
 			if (paramsAnnotation != null) {
-				annotationGen.addForParameter(argsCode, paramsAnnotation, i);
+				annotationGen.addForParameter(code, paramsAnnotation, i);
 			}
-			SSAVar argSVar = arg.getSVar();
-			if (argSVar!= null && argSVar.contains(AFlag.FINAL)) {
-				argsCode.add("final ");
+			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();
-					classGen.useType(argsCode, 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"));
-					classGen.useType(argsCode, arg.getType());
+					mth.addComment("JADX INFO: Last argument in varargs method is not array: " + var);
+					classGen.useType(code, argType);
 				}
 			} else {
-				classGen.useType(argsCode, arg.getType());
+				classGen.useType(code, argType);
 			}
-			argsCode.add(' ');
-			argsCode.add(nameGen.assignArg(arg));
+			code.add(' ');
+			code.add(nameGen.assignArg(var));
 
 			i++;
 			if (it.hasNext()) {
-				argsCode.add(", ");
+				code.add(", ");
 			}
 		}
 	}
 
 	public void addInstructions(CodeWriter code) throws CodegenException {
-		if (mth.contains(AType.JADX_ERROR)
-				|| mth.contains(AFlag.INCONSISTENT_CODE)
-				|| mth.getRegion() == null) {
-			JadxErrorAttr err = mth.get(AType.JADX_ERROR);
-			if (err != null) {
-				code.startLine("/* JADX: method processing error */");
-				Throwable cause = err.getCause();
-				if (cause != null) {
-					code.newLine();
-					code.add("/*");
-					code.newLine().add("Error: ").add(Utils.getStackTrace(cause));
-					code.add("*/");
-				}
-			}
-			code.startLine("/*");
+		if (mth.root().getArgs().isFallbackMode()) {
 			addFallbackMethodCode(code);
-			code.startLine("*/");
-
-			code.startLine("throw new UnsupportedOperationException(\"Method not decompiled: ")
-					.add(mth.toString())
-					.add("\");");
+		} else if (classGen.isFallbackMode()) {
+			dumpInstructions(code);
 		} else {
+			addRegionInsns(code);
+		}
+	}
+
+	public void addRegionInsns(CodeWriter 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"));
+			classGen.insertDecompilationProblems(code, mth);
+			dumpInstructions(code);
+		} catch (Exception e) {
+			if (mth.getParentClass().getTopParentClass().contains(AFlag.RESTART_CODEGEN)) {
+				throw e;
+			}
+			mth.addError("Method code generation error", e);
+			classGen.insertDecompilationProblems(code, mth);
+			dumpInstructions(code);
 		}
 	}
 
+	public void dumpInstructions(CodeWriter code) {
+		code.startLine("/*");
+		addFallbackMethodCode(code);
+		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("\");");
+	}
+
 	public void addFallbackMethodCode(CodeWriter code) {
 		if (mth.getInstructions() == null) {
-			JadxErrorAttr errorAttr = mth.get(AType.JADX_ERROR);
-			if (errorAttr == null
-					|| errorAttr.getCause() == null
-					|| !errorAttr.getCause().getClass().equals(DecodeException.class)) {
-				// load original instructions
-				try {
-					mth.load();
-					DepthTraversal.visit(new FallbackModeVisitor(), mth);
-				} catch (DecodeException e) {
-					LOG.error("Error reload instructions in fallback mode:", e);
-					code.startLine("// Can't load method instructions: " + e.getMessage());
-					return;
-				}
+			// load original instructions
+			try {
+				mth.unload();
+				mth.load();
+				DepthTraversal.visit(new FallbackModeVisitor(), mth);
+			} catch (DecodeException e) {
+				LOG.error("Error reload instructions in fallback mode:", e);
+				code.startLine("// Can't load method instructions: " + e.getMessage());
+				return;
 			}
 		}
 		InsnNode[] insnArr = mth.getInstructions();
@@ -206,47 +257,85 @@ public class MethodGen {
 			code.startLine("// Can't load method instructions.");
 			return;
 		}
+		code.incIndent();
 		if (mth.getThisArg() != null) {
 			code.startLine(nameGen.useArg(mth.getThisArg())).add(" = this;");
 		}
 		addFallbackInsns(code, mth, insnArr, true);
+		code.decIndent();
 	}
 
 	public static void addFallbackInsns(CodeWriter code, MethodNode mth, InsnNode[] insnArr, boolean addLabels) {
 		InsnGen insnGen = new InsnGen(getFallbackMethodGen(mth), true);
+		boolean attachInsns = mth.root().getArgs().isJsonOutput();
+		InsnNode prevInsn = null;
 		for (InsnNode insn : insnArr) {
-			if (insn == null || insn.getType() == InsnType.NOP) {
+			if (insn == null) {
 				continue;
 			}
-			if (addLabels && (insn.contains(AType.JUMP) || insn.contains(AType.EXC_HANDLER))) {
+			if (addLabels && needLabel(insn, prevInsn)) {
 				code.decIndent();
-				code.startLine(getLabelName(insn.getOffset()) + ":");
+				code.startLine(getLabelName(insn.getOffset()) + ':');
 				code.incIndent();
 			}
+			if (insn.getType() == InsnType.NOP) {
+				continue;
+			}
 			try {
-				if (insnGen.makeInsn(insn, code)) {
-					CatchAttr catchAttr = insn.get(AType.CATCH_BLOCK);
-					if (catchAttr != null) {
-						code.add("\t " + catchAttr);
+				code.startLine();
+				if (attachInsns) {
+					code.attachLineAnnotation(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);
+				CatchAttr catchAttr = insn.get(AType.CATCH_BLOCK);
+				if (catchAttr != null) {
+					code.add("     // " + catchAttr);
+				}
 			} catch (CodegenException e) {
 				LOG.debug("Error generate fallback instruction: ", e.getCause());
 				code.startLine("// error: " + insn);
 			}
+			prevInsn = insn;
 		}
 	}
 
+	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
 	 */
 	public static MethodGen getFallbackMethodGen(MethodNode mth) {
-		ClassGen clsGen = new ClassGen(mth.getParentClass(), null, true, true);
+		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

@@ -1,5 +1,10 @@
 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;
@@ -7,58 +12,72 @@ 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 java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import jadx.core.utils.Utils;
 
 public class NameGen {
 
 	private static final Map<String, String> OBJ_ALIAS;
 
-	private final Set<String> varNames = new HashSet<String>();
+	private final Set<String> varNames = new HashSet<>();
 	private final MethodNode mth;
 	private final boolean fallback;
 
 	static {
-		OBJ_ALIAS = new HashMap<String, String>();
-		OBJ_ALIAS.put(Consts.CLASS_STRING, "str");
-		OBJ_ALIAS.put(Consts.CLASS_CLASS, "cls");
-		OBJ_ALIAS.put(Consts.CLASS_THROWABLE, "th");
-		OBJ_ALIAS.put(Consts.CLASS_OBJECT, "obj");
-		OBJ_ALIAS.put("java.util.Iterator", "it");
-		OBJ_ALIAS.put("java.lang.Boolean", "bool");
-		OBJ_ALIAS.put("java.lang.Short", "sh");
-		OBJ_ALIAS.put("java.lang.Integer", "num");
-		OBJ_ALIAS.put("java.lang.Character", "ch");
-		OBJ_ALIAS.put("java.lang.Byte", "b");
-		OBJ_ALIAS.put("java.lang.Float", "f");
-		OBJ_ALIAS.put("java.lang.Long", "l");
-		OBJ_ALIAS.put("java.lang.Double", "d");
+		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, boolean fallback) {
 		this.mth = mth;
 		this.fallback = fallback;
+		addNamesUsedInClass();
 	}
 
-	public String assignArg(RegisterArg arg) {
-		String name = makeArgName(arg);
+	private void addNamesUsedInClass() {
+		ClassNode parentClass = mth.getParentClass();
+		for (FieldNode field : parentClass.getFields()) {
+			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) {
+		String name = makeArgName(var);
 		if (fallback) {
 			return name;
 		}
 		name = getUniqueVarName(name);
-		arg.setName(name);
+		var.setName(name);
 		return name;
 	}
 
@@ -98,54 +117,67 @@ public class NameGen {
 		return r;
 	}
 
-	private String makeArgName(RegisterArg arg) {
+	private String makeArgName(CodeVar var) {
 		if (fallback) {
-			return getFallbackName(arg);
+			return getFallbackName(var);
 		}
-		String name = arg.getName();
-		String varName;
-		if (name != null) {
-			if ("this".equals(name)) {
-				return name;
-			}
-			varName = name;
-		} else {
-			varName = guessName(arg);
+		if (var.isThis()) {
+			return RegisterArg.THIS_ARG_NAME;
 		}
+		String name = var.getName();
+		String varName = name != null ? name : guessName(var);
 		if (NameMapper.isReserved(varName)) {
-			return varName + "R";
+			varName = varName + 'R';
+		}
+		if (!NameMapper.isValidAndPrintable(varName)) {
+			varName = getFallbackName(var);
+		}
+		if (Consts.DEBUG) {
+			varName += '_' + getFallbackName(var);
 		}
 		return varName;
 	}
 
+	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(RegisterArg arg) {
-		SSAVar sVar = arg.getSVar();
-		if (sVar != null && sVar.getName() == null) {
-			RegisterArg assignArg = sVar.getAssign();
-			InsnNode assignInsn = assignArg.getParentInsn();
-			if (assignInsn != null) {
-				String name = makeNameFromInsn(assignInsn);
-				if (name != null && !NameMapper.isReserved(name)) {
-					assignArg.setName(name);
-					return name;
+	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(arg.getType());
+		return makeNameForType(var.getType());
 	}
 
 	private String makeNameForType(ArgType type) {
 		if (type.isPrimitive()) {
 			return makeNameForPrimitive(type);
-		} else if (type.isArray()) {
-			return makeNameForType(type.getArrayRootElement()) + "Arr";
-		} else {
-			return makeNameForObject(type);
 		}
+		if (type.isArray()) {
+			return makeNameForType(type.getArrayRootElement()) + "Arr";
+		}
+		return makeNameForObject(type);
 	}
 
 	private static String makeNameForPrimitive(ArgType type) {
@@ -153,17 +185,23 @@ public class NameGen {
 	}
 
 	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.extCls(mth.dex(), type);
+			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());
 	}
@@ -228,16 +266,19 @@ public class NameGen {
 		if (name.startsWith("get") || name.startsWith("set")) {
 			return fromName(name.substring(3));
 		}
-		ArgType declType = callMth.getDeclClass().getAlias().getType();
 		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;
 	}
 }

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

@@ -1,11 +1,21 @@
 package jadx.core.codegen;
 
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.DeclareVariablesAttr;
 import jadx.core.dex.attributes.nodes.ForceReturnAttr;
 import jadx.core.dex.attributes.nodes.LoopLabelAttr;
+import jadx.core.dex.info.ClassInfo;
 import jadx.core.dex.instructions.SwitchNode;
+import jadx.core.dex.instructions.args.CodeVar;
 import jadx.core.dex.instructions.args.InsnArg;
 import jadx.core.dex.instructions.args.NamedArg;
 import jadx.core.dex.instructions.args.RegisterArg;
@@ -27,17 +37,12 @@ import jadx.core.dex.regions.loops.ForLoop;
 import jadx.core.dex.regions.loops.LoopRegion;
 import jadx.core.dex.regions.loops.LoopType;
 import jadx.core.dex.trycatch.ExceptionHandler;
+import jadx.core.utils.BlockUtils;
 import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.RegionUtils;
 import jadx.core.utils.exceptions.CodegenException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import java.util.List;
-import java.util.Map;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 public class RegionGen extends InsnGen {
 	private static final Logger LOG = LoggerFactory.getLogger(RegionGen.class);
 
@@ -73,7 +78,7 @@ public class RegionGen extends InsnGen {
 	private void declareVars(CodeWriter code, IContainer cont) {
 		DeclareVariablesAttr declVars = cont.get(AType.DECLARE_VARIABLES);
 		if (declVars != null) {
-			for (RegisterArg v : declVars.getVars()) {
+			for (CodeVar v : declVars.getVars()) {
 				code.startLine();
 				declareVar(code, v);
 				code.add(';');
@@ -95,8 +100,12 @@ public class RegionGen extends InsnGen {
 	}
 
 	private void makeSimpleBlock(IBlock block, CodeWriter code) throws CodegenException {
+		if (block.contains(AFlag.DONT_GENERATE)) {
+			return;
+		}
+
 		for (InsnNode insn : block.getInstructions()) {
-			if (!insn.contains(AFlag.SKIP)) {
+			if (!insn.contains(AFlag.DONT_GENERATE)) {
 				makeInsn(insn, code);
 			}
 		}
@@ -112,21 +121,44 @@ public class RegionGen extends InsnGen {
 		} else {
 			code.attachSourceLine(region.getSourceLine());
 		}
+		if (attachInsns) {
+			List<BlockNode> conditionBlocks = region.getConditionBlocks();
+			if (!conditionBlocks.isEmpty()) {
+				BlockNode blockNode = conditionBlocks.get(0);
+				InsnNode lastInsn = BlockUtils.getLastInsn(blockNode);
+				if (lastInsn != null) {
+					code.attachLineAnnotation(lastInsn);
+				}
+			}
+		}
+		boolean comment = region.contains(AFlag.COMMENT_OUT);
+		if (comment) {
+			code.add("// ");
+		}
+
 		code.add("if (");
 		new ConditionGen(this).add(code, region.getCondition());
 		code.add(") {");
 		makeRegionIndent(code, region.getThenRegion());
-		code.startLine('}');
+		if (comment) {
+			code.startLine("// }");
+		} else {
+			code.startLine('}');
+		}
 
 		IContainer els = region.getElseRegion();
-		if (els != null && RegionUtils.notEmpty(els)) {
+		if (RegionUtils.notEmpty(els)) {
 			code.add(" else ");
 			if (connectElseIf(code, els)) {
 				return;
 			}
 			code.add('{');
 			makeRegionIndent(code, els);
-			code.startLine('}');
+			if (comment) {
+				code.startLine("// }");
+			} else {
+				code.startLine('}');
+			}
 		}
 	}
 
@@ -134,17 +166,16 @@ public class RegionGen extends InsnGen {
 	 * Connect if-else-if block
 	 */
 	private boolean connectElseIf(CodeWriter code, IContainer els) throws CodegenException {
-		if (!els.contains(AFlag.ELSE_IF_CHAIN)) {
-			return false;
-		}
-		if (!(els instanceof Region)) {
-			return false;
-		}
-		List<IContainer> subBlocks = ((Region) els).getSubBlocks();
-		if (subBlocks.size() == 1
-				&& subBlocks.get(0) instanceof IfRegion) {
-			makeIf((IfRegion) subBlocks.get(0), code, false);
-			return true;
+		if (els.contains(AFlag.ELSE_IF_CHAIN) && els instanceof Region) {
+			List<IContainer> subBlocks = ((Region) els).getSubBlocks();
+			if (subBlocks.size() == 1) {
+				IContainer elseBlock = subBlocks.get(0);
+				if (elseBlock instanceof IfRegion) {
+					declareVars(code, elseBlock);
+					makeIf((IfRegion) elseBlock, code, false);
+					return true;
+				}
+			}
 		}
 		return false;
 	}
@@ -154,7 +185,7 @@ public class RegionGen extends InsnGen {
 		if (header != null) {
 			List<InsnNode> headerInsns = header.getInstructions();
 			if (headerInsns.size() > 1) {
-				ErrorsCounter.methodError(mth, "Found not inlined instructions from loop header");
+				ErrorsCounter.methodWarn(mth, "Found not inlined instructions from loop header");
 				int last = headerInsns.size() - 1;
 				for (int i = 0; i < last; i++) {
 					InsnNode insn = headerInsns.get(i);
@@ -207,11 +238,13 @@ public class RegionGen extends InsnGen {
 		if (region.isConditionAtEnd()) {
 			code.startLine("do {");
 			makeRegionIndent(code, region.getBody());
-			code.startLine("} while (");
+			code.startLineWithNum(region.getConditionSourceLine());
+			code.add("} while (");
 			conditionGen.add(code, condition);
 			code.add(");");
 		} else {
-			code.startLine("while (");
+			code.startLineWithNum(region.getConditionSourceLine());
+			code.add("while (");
 			conditionGen.add(code, condition);
 			code.add(") {");
 			makeRegionIndent(code, region.getBody());
@@ -229,7 +262,8 @@ public class RegionGen extends InsnGen {
 	}
 
 	private CodeWriter makeSwitch(SwitchRegion sw, CodeWriter code) throws CodegenException {
-		SwitchNode insn = (SwitchNode) sw.getHeader().getInstructions().get(0);
+		SwitchNode insn = (SwitchNode) BlockUtils.getLastInsn(sw.getHeader());
+		Objects.requireNonNull(insn, "Switch insn not found in header");
 		InsnArg arg = insn.getArg(0);
 		code.startLine("switch (");
 		addArg(code, arg, false);
@@ -255,7 +289,7 @@ public class RegionGen extends InsnGen {
 						}
 					}
 				} else if (k instanceof Integer) {
-					code.add(TypeGen.literalToString((Integer) k, arg.getType(), mth));
+					code.add(TypeGen.literalToString((Integer) k, arg.getType(), mth, fallback));
 				} else {
 					throw new JadxRuntimeException("Unexpected key in switch: " + (k != null ? k.getClass() : null));
 				}
@@ -305,16 +339,24 @@ public class RegionGen extends InsnGen {
 			return;
 		}
 		code.startLine("} catch (");
+		if (handler.isCatchAll()) {
+			code.add("Throwable");
+		} else {
+			Iterator<ClassInfo> it = handler.getCatchTypes().iterator();
+			if (it.hasNext()) {
+				useClass(code, it.next());
+			}
+			while (it.hasNext()) {
+				code.add(" | ");
+				useClass(code, it.next());
+			}
+		}
+		code.add(' ');
 		InsnArg arg = handler.getArg();
 		if (arg instanceof RegisterArg) {
-			declareVar(code, (RegisterArg) arg);
+			RegisterArg reg = (RegisterArg) arg;
+			code.add(mgen.getNameGen().assignArg(reg.getSVar().getCodeVar()));
 		} else if (arg instanceof NamedArg) {
-			if (handler.isCatchAll()) {
-				code.add("Throwable");
-			} else {
-				useClass(code, handler.getCatchType());
-			}
-			code.add(' ');
 			code.add(mgen.getNameGen().assignNamedArg((NamedArg) arg));
 		}
 		code.add(") {");

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

@@ -1,16 +1,18 @@
 package jadx.core.codegen;
 
-import jadx.api.JadxArgs;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.core.deobf.NameMapper;
+import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.instructions.args.LiteralArg;
 import jadx.core.dex.instructions.args.PrimitiveType;
 import jadx.core.dex.nodes.IDexNode;
 import jadx.core.utils.StringUtils;
 import jadx.core.utils.Utils;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 public class TypeGen {
 	private static final Logger LOG = LoggerFactory.getLogger(TypeGen.class);
 
@@ -28,27 +30,39 @@ public class TypeGen {
 		return stype.getShortName();
 	}
 
+	/**
+	 * Convert literal arg to string (preferred method)
+	 */
+	public static String literalToString(LiteralArg arg, IDexNode dexNode, boolean fallback) {
+		return literalToString(arg.getLiteral(), arg.getType(),
+				dexNode.root().getStringUtils(),
+				fallback,
+				arg.contains(AFlag.EXPLICIT_PRIMITIVE_TYPE));
+	}
+
 	/**
 	 * Convert literal value to string according to value type
 	 *
 	 * @throws JadxRuntimeException for incorrect type or literal value
 	 */
-	public static String literalToString(long lit, ArgType type, IDexNode dexNode) {
-		return literalToString(lit, type, dexNode.root().getStringUtils());
+	public static String literalToString(long lit, ArgType type, IDexNode dexNode, boolean fallback) {
+		return literalToString(lit, type, dexNode.root().getStringUtils(), fallback, false);
 	}
 
-	@Deprecated
-	public static String literalToString(long lit, ArgType type) {
-		return literalToString(lit, type, new StringUtils(new JadxArgs()));
-	}
-
-	private static String literalToString(long lit, ArgType type, StringUtils stringUtils) {
+	public static String literalToString(long lit, ArgType type, StringUtils stringUtils, boolean fallback, boolean cast) {
 		if (type == null || !type.isTypeKnown()) {
 			String n = Long.toString(lit);
-			if (Math.abs(lit) > 100) {
-				n += "; // 0x" + Long.toHexString(lit)
-						+ " float:" + Float.intBitsToFloat((int) lit)
-						+ " double:" + Double.longBitsToDouble(lit);
+			if (fallback && Math.abs(lit) > 100) {
+				StringBuilder sb = new StringBuilder();
+				sb.append(n).append("(0x").append(Long.toHexString(lit));
+				if (type == null || type.contains(PrimitiveType.FLOAT)) {
+					sb.append(", float:").append(Float.intBitsToFloat((int) lit));
+				}
+				if (type == null || type.contains(PrimitiveType.DOUBLE)) {
+					sb.append(", double:").append(Double.longBitsToDouble(lit));
+				}
+				sb.append(')');
+				return sb.toString();
 			}
 			return n;
 		}
@@ -57,15 +71,19 @@ public class TypeGen {
 			case BOOLEAN:
 				return lit == 0 ? "false" : "true";
 			case CHAR:
-				return stringUtils.unescapeChar((char) lit);
+				char ch = (char) lit;
+				if (!NameMapper.isPrintableChar(ch)) {
+					return Integer.toString(ch);
+				}
+				return stringUtils.unescapeChar(ch);
 			case BYTE:
-				return formatByte((byte) lit);
+				return formatByte(lit, cast);
 			case SHORT:
-				return formatShort((short) lit);
+				return formatShort(lit, cast);
 			case INT:
-				return formatInteger((int) lit);
+				return formatInteger(lit, cast);
 			case LONG:
-				return formatLong(lit);
+				return formatLong(lit, cast);
 			case FLOAT:
 				return formatFloat(Float.intBitsToFloat((int) lit));
 			case DOUBLE:
@@ -84,37 +102,40 @@ public class TypeGen {
 		}
 	}
 
-	public static String formatShort(short s) {
-		if (s == Short.MAX_VALUE) {
+	public static String formatShort(long l, boolean cast) {
+		if (l == Short.MAX_VALUE) {
 			return "Short.MAX_VALUE";
 		}
-		if (s == Short.MIN_VALUE) {
+		if (l == Short.MIN_VALUE) {
 			return "Short.MIN_VALUE";
 		}
-		return "(short) " + Short.toString(s);
+		String str = Long.toString(l);
+		return cast ? "(short) " + str : str;
 	}
 
-	public static String formatByte(byte b) {
-		if (b == Byte.MAX_VALUE) {
+	public static String formatByte(long l, boolean cast) {
+		if (l == Byte.MAX_VALUE) {
 			return "Byte.MAX_VALUE";
 		}
-		if (b == Byte.MIN_VALUE) {
+		if (l == Byte.MIN_VALUE) {
 			return "Byte.MIN_VALUE";
 		}
-		return "(byte) " + Byte.toString(b);
+		String str = Long.toString(l);
+		return cast ? "(byte) " + str : str;
 	}
 
-	public static String formatInteger(int i) {
-		if (i == Integer.MAX_VALUE) {
+	public static String formatInteger(long l, boolean cast) {
+		if (l == Integer.MAX_VALUE) {
 			return "Integer.MAX_VALUE";
 		}
-		if (i == Integer.MIN_VALUE) {
+		if (l == Integer.MIN_VALUE) {
 			return "Integer.MIN_VALUE";
 		}
-		return Integer.toString(i);
+		String str = Long.toString(l);
+		return cast ? "(int) " + str : str;
 	}
 
-	public static String formatLong(long l) {
+	public static String formatLong(long l, boolean cast) {
 		if (l == Long.MAX_VALUE) {
 			return "Long.MAX_VALUE";
 		}
@@ -122,8 +143,8 @@ public class TypeGen {
 			return "Long.MIN_VALUE";
 		}
 		String str = Long.toString(l);
-		if (Math.abs(l) >= Integer.MAX_VALUE) {
-			str += "L";
+		if (cast || Math.abs(l) >= Integer.MAX_VALUE) {
+			return str + 'L';
 		}
 		return str;
 	}
@@ -147,7 +168,7 @@ public class TypeGen {
 		if (d == Double.MIN_NORMAL) {
 			return "Double.MIN_NORMAL";
 		}
-		return Double.toString(d) + "d";
+		return Double.toString(d) + 'd';
 	}
 
 	public static String formatFloat(float f) {
@@ -169,7 +190,6 @@ public class TypeGen {
 		if (f == Float.MIN_NORMAL) {
 			return "Float.MIN_NORMAL";
 		}
-		return Float.toString(f) + "f";
+		return Float.toString(f) + 'f';
 	}
-
 }

jadx-core/src/main/java/jadx/core/codegen/json/JsonCodeGen.java

@@ -0,0 +1,224 @@
+package jadx.core.codegen.json;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import org.jetbrains.annotations.Nullable;
+
+import com.google.gson.FieldNamingPolicy;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import jadx.api.CodePosition;
+import jadx.api.JadxArgs;
+import jadx.core.codegen.ClassGen;
+import jadx.core.codegen.CodeWriter;
+import jadx.core.codegen.MethodGen;
+import jadx.core.codegen.json.cls.JsonClass;
+import jadx.core.codegen.json.cls.JsonCodeLine;
+import jadx.core.codegen.json.cls.JsonField;
+import jadx.core.codegen.json.cls.JsonMethod;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.instructions.args.ArgType;
+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.dex.nodes.RootNode;
+import jadx.core.utils.CodeGenUtils;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
+public class JsonCodeGen {
+
+	private static final Gson GSON = new GsonBuilder()
+			.setPrettyPrinting()
+			.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_DASHES)
+			.disableHtmlEscaping()
+			.create();
+
+	private final ClassNode cls;
+	private final JadxArgs args;
+	private final RootNode root;
+
+	public JsonCodeGen(ClassNode cls) {
+		this.cls = cls;
+		this.root = cls.root();
+		this.args = root.getArgs();
+	}
+
+	public String process() {
+		JsonClass jsonCls = processCls(cls, null);
+		return GSON.toJson(jsonCls);
+	}
+
+	private JsonClass processCls(ClassNode cls, @Nullable ClassGen parentCodeGen) {
+		ClassGen classGen;
+		if (parentCodeGen == null) {
+			classGen = new ClassGen(cls, args);
+		} else {
+			classGen = new ClassGen(cls, parentCodeGen);
+		}
+		ClassInfo classInfo = cls.getClassInfo();
+
+		JsonClass jsonCls = new JsonClass();
+		jsonCls.setPkg(classInfo.getAliasPkg());
+		jsonCls.setDex(cls.dex().getDexFile().getName());
+		jsonCls.setName(classInfo.getFullName());
+		if (classInfo.hasAlias()) {
+			jsonCls.setAlias(classInfo.getAliasFullName());
+		}
+		jsonCls.setType(getClassTypeStr(cls));
+		jsonCls.setAccessFlags(cls.getAccessFlags().rawValue());
+		if (!Objects.equals(cls.getSuperClass(), ArgType.OBJECT)) {
+			jsonCls.setSuperClass(getTypeAlias(cls.getSuperClass()));
+		}
+		if (!cls.getInterfaces().isEmpty()) {
+			jsonCls.setInterfaces(Utils.collectionMap(cls.getInterfaces(), this::getTypeAlias));
+		}
+
+		CodeWriter cw = new CodeWriter();
+		CodeGenUtils.addComments(cw, cls);
+		classGen.insertDecompilationProblems(cw, cls);
+		classGen.addClassDeclaration(cw);
+		jsonCls.setDeclaration(cw.finish().toString());
+
+		addFields(cls, jsonCls, classGen);
+		addMethods(cls, jsonCls, classGen);
+		addInnerClasses(cls, jsonCls, classGen);
+
+		if (!cls.getClassInfo().isInner()) {
+			List<String> imports = Utils.collectionMap(classGen.getImports(), ClassInfo::getAliasFullName);
+			Collections.sort(imports);
+			jsonCls.setImports(imports);
+		}
+		return jsonCls;
+	}
+
+	private void addInnerClasses(ClassNode cls, JsonClass jsonCls, ClassGen classGen) {
+		List<ClassNode> innerClasses = cls.getInnerClasses();
+		if (innerClasses.isEmpty()) {
+			return;
+		}
+		jsonCls.setInnerClasses(new ArrayList<>(innerClasses.size()));
+		for (ClassNode innerCls : innerClasses) {
+			if (innerCls.contains(AFlag.DONT_GENERATE)) {
+				continue;
+			}
+			JsonClass innerJsonCls = processCls(innerCls, classGen);
+			jsonCls.getInnerClasses().add(innerJsonCls);
+		}
+	}
+
+	private void addFields(ClassNode cls, JsonClass jsonCls, ClassGen classGen) {
+		jsonCls.setFields(new ArrayList<>());
+		for (FieldNode field : cls.getFields()) {
+			if (field.contains(AFlag.DONT_GENERATE)) {
+				continue;
+			}
+			JsonField jsonField = new JsonField();
+			jsonField.setName(field.getName());
+			if (field.getFieldInfo().hasAlias()) {
+				jsonField.setAlias(field.getAlias());
+			}
+
+			CodeWriter cw = new CodeWriter();
+			classGen.addField(cw, field);
+			jsonField.setDeclaration(cw.finish().toString());
+			jsonField.setAccessFlags(field.getAccessFlags().rawValue());
+
+			jsonCls.getFields().add(jsonField);
+		}
+	}
+
+	private void addMethods(ClassNode cls, JsonClass jsonCls, ClassGen classGen) {
+		jsonCls.setMethods(new ArrayList<>());
+		for (MethodNode mth : cls.getMethods()) {
+			if (mth.contains(AFlag.DONT_GENERATE)) {
+				continue;
+			}
+			JsonMethod jsonMth = new JsonMethod();
+			jsonMth.setName(mth.getName());
+			if (mth.getMethodInfo().hasAlias()) {
+				jsonMth.setAlias(mth.getAlias());
+			}
+			jsonMth.setSignature(mth.getMethodInfo().getShortId());
+			jsonMth.setReturnType(getTypeAlias(mth.getReturnType()));
+			jsonMth.setArguments(Utils.collectionMap(mth.getMethodInfo().getArgumentsTypes(), this::getTypeAlias));
+
+			MethodGen mthGen = new MethodGen(classGen, mth);
+			CodeWriter cw = new CodeWriter();
+			mthGen.addDefinition(cw);
+			jsonMth.setDeclaration(cw.finish().toString());
+			jsonMth.setAccessFlags(mth.getAccessFlags().rawValue());
+			jsonMth.setLines(fillMthCode(mth, mthGen));
+			jsonMth.setOffset("0x" + Long.toHexString(mth.getMethodCodeOffset()));
+			jsonCls.getMethods().add(jsonMth);
+		}
+	}
+
+	private List<JsonCodeLine> fillMthCode(MethodNode mth, MethodGen mthGen) {
+		if (mth.isNoCode()) {
+			return Collections.emptyList();
+		}
+
+		CodeWriter code = new CodeWriter();
+		try {
+			mthGen.addInstructions(code);
+		} catch (Exception e) {
+			throw new JadxRuntimeException("Method generation error", e);
+		}
+		code.finish();
+		String codeStr = code.toString();
+		if (codeStr.isEmpty()) {
+			return Collections.emptyList();
+		}
+
+		String[] lines = codeStr.split(CodeWriter.NL);
+		Map<Integer, Integer> lineMapping = code.getLineMapping();
+		Map<CodePosition, Object> annotations = code.getAnnotations();
+		long mthCodeOffset = mth.getMethodCodeOffset() + 16;
+
+		int linesCount = lines.length;
+		List<JsonCodeLine> codeLines = new ArrayList<>(linesCount);
+		for (int i = 0; i < linesCount; i++) {
+			String codeLine = lines[i];
+			int line = i + 2;
+			JsonCodeLine jsonCodeLine = new JsonCodeLine();
+			jsonCodeLine.setCode(codeLine);
+			jsonCodeLine.setSourceLine(lineMapping.get(line));
+			Object obj = annotations.get(new CodePosition(line, 0));
+			if (obj instanceof InsnNode) {
+				long offset = ((InsnNode) obj).getOffset();
+				jsonCodeLine.setOffset("0x" + Long.toHexString(mthCodeOffset + offset * 2));
+			}
+			codeLines.add(jsonCodeLine);
+		}
+		return codeLines;
+	}
+
+	private String getTypeAlias(ArgType clsType) {
+		if (Objects.equals(clsType, ArgType.OBJECT)) {
+			return ArgType.OBJECT.getObject();
+		}
+		if (clsType.isObject()) {
+			ClassInfo classInfo = ClassInfo.fromType(root, clsType);
+			return classInfo.getAliasFullName();
+		}
+		return clsType.toString();
+	}
+
+	private String getClassTypeStr(ClassNode cls) {
+		if (cls.isEnum()) {
+			return "enum";
+		}
+		if (cls.getAccessFlags().isInterface()) {
+			return "interface";
+		}
+		return "class";
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/JsonMappingGen.java

@@ -0,0 +1,107 @@
+package jadx.core.codegen.json;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.FieldNamingPolicy;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import jadx.api.JadxArgs;
+import jadx.core.codegen.json.mapping.JsonClsMapping;
+import jadx.core.codegen.json.mapping.JsonFieldMapping;
+import jadx.core.codegen.json.mapping.JsonMapping;
+import jadx.core.codegen.json.mapping.JsonMthMapping;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.info.MethodInfo;
+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.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+
+public class JsonMappingGen {
+	private static final Logger LOG = LoggerFactory.getLogger(JsonMappingGen.class);
+
+	private static final Gson GSON = new GsonBuilder()
+			.setPrettyPrinting()
+			.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_DASHES)
+			.disableHtmlEscaping()
+			.create();
+
+	public static void dump(RootNode root) {
+		JsonMapping mapping = new JsonMapping();
+		fillMapping(mapping, root);
+
+		JadxArgs args = root.getArgs();
+		File outDirSrc = args.getOutDirSrc().getAbsoluteFile();
+		File mappingFile = new File(outDirSrc, "mapping.json");
+		FileUtils.makeDirsForFile(mappingFile);
+		try (Writer writer = new FileWriter(mappingFile)) {
+			GSON.toJson(mapping, writer);
+			LOG.info("Save mappings to {}", mappingFile.getAbsolutePath());
+		} catch (Exception e) {
+			throw new JadxRuntimeException("Failed to save mapping json", e);
+		}
+	}
+
+	private static void fillMapping(JsonMapping mapping, RootNode root) {
+		List<ClassNode> classes = root.getClasses(true);
+		mapping.setClasses(new ArrayList<>(classes.size()));
+		for (ClassNode cls : classes) {
+			ClassInfo classInfo = cls.getClassInfo();
+			JsonClsMapping jsonCls = new JsonClsMapping();
+			jsonCls.setName(classInfo.getRawName());
+			jsonCls.setAlias(classInfo.getAliasFullName());
+			jsonCls.setInner(classInfo.isInner());
+			jsonCls.setJson(cls.getTopParentClass().getClassInfo().getAliasFullPath() + ".json");
+			if (classInfo.isInner()) {
+				jsonCls.setTopClass(cls.getTopParentClass().getClassInfo().getFullName());
+			}
+			addFields(cls, jsonCls);
+			addMethods(cls, jsonCls);
+			mapping.getClasses().add(jsonCls);
+		}
+	}
+
+	private static void addMethods(ClassNode cls, JsonClsMapping jsonCls) {
+		List<MethodNode> methods = cls.getMethods();
+		if (methods.isEmpty()) {
+			return;
+		}
+		jsonCls.setMethods(new ArrayList<>(methods.size()));
+		for (MethodNode method : methods) {
+			JsonMthMapping jsonMethod = new JsonMthMapping();
+			MethodInfo methodInfo = method.getMethodInfo();
+			jsonMethod.setSignature(methodInfo.getShortId());
+			jsonMethod.setName(methodInfo.getName());
+			jsonMethod.setAlias(methodInfo.getAlias());
+			jsonMethod.setOffset("0x" + Long.toHexString(method.getMethodCodeOffset()));
+			jsonCls.getMethods().add(jsonMethod);
+		}
+	}
+
+	private static void addFields(ClassNode cls, JsonClsMapping jsonCls) {
+		List<FieldNode> fields = cls.getFields();
+		if (fields.isEmpty()) {
+			return;
+		}
+		jsonCls.setFields(new ArrayList<>(fields.size()));
+		for (FieldNode field : fields) {
+			JsonFieldMapping jsonField = new JsonFieldMapping();
+			jsonField.setName(field.getName());
+			jsonField.setAlias(field.getAlias());
+			jsonCls.getFields().add(jsonField);
+		}
+	}
+
+	private JsonMappingGen() {
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/cls/JsonClass.java

@@ -0,0 +1,94 @@
+package jadx.core.codegen.json.cls;
+
+import java.util.List;
+
+import com.google.gson.annotations.SerializedName;
+
+public class JsonClass extends JsonNode {
+	@SerializedName("package")
+	private String pkg;
+	private String type; // class, interface, enum
+	@SerializedName("extends")
+	private String superClass;
+	@SerializedName("implements")
+	private List<String> interfaces;
+	private String dex;
+
+	private List<JsonField> fields;
+	private List<JsonMethod> methods;
+	private List<JsonClass> innerClasses;
+
+	private List<String> imports;
+
+	public String getType() {
+		return type;
+	}
+
+	public void setType(String type) {
+		this.type = type;
+	}
+
+	public String getSuperClass() {
+		return superClass;
+	}
+
+	public void setSuperClass(String superClass) {
+		this.superClass = superClass;
+	}
+
+	public List<String> getInterfaces() {
+		return interfaces;
+	}
+
+	public void setInterfaces(List<String> interfaces) {
+		this.interfaces = interfaces;
+	}
+
+	public List<JsonField> getFields() {
+		return fields;
+	}
+
+	public void setFields(List<JsonField> fields) {
+		this.fields = fields;
+	}
+
+	public List<JsonMethod> getMethods() {
+		return methods;
+	}
+
+	public void setMethods(List<JsonMethod> methods) {
+		this.methods = methods;
+	}
+
+	public List<JsonClass> getInnerClasses() {
+		return innerClasses;
+	}
+
+	public void setInnerClasses(List<JsonClass> innerClasses) {
+		this.innerClasses = innerClasses;
+	}
+
+	public String getPkg() {
+		return pkg;
+	}
+
+	public void setPkg(String pkg) {
+		this.pkg = pkg;
+	}
+
+	public String getDex() {
+		return dex;
+	}
+
+	public void setDex(String dex) {
+		this.dex = dex;
+	}
+
+	public List<String> getImports() {
+		return imports;
+	}
+
+	public void setImports(List<String> imports) {
+		this.imports = imports;
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/cls/JsonCodeLine.java

@@ -0,0 +1,33 @@
+package jadx.core.codegen.json.cls;
+
+import org.jetbrains.annotations.Nullable;
+
+public class JsonCodeLine {
+	private String code;
+	private String offset;
+	private Integer sourceLine;
+
+	public String getCode() {
+		return code;
+	}
+
+	public void setCode(String code) {
+		this.code = code;
+	}
+
+	public String getOffset() {
+		return offset;
+	}
+
+	public void setOffset(String offset) {
+		this.offset = offset;
+	}
+
+	public Integer getSourceLine() {
+		return sourceLine;
+	}
+
+	public void setSourceLine(@Nullable Integer sourceLine) {
+		this.sourceLine = sourceLine;
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/cls/JsonField.java

@@ -0,0 +1,5 @@
+package jadx.core.codegen.json.cls;
+
+public class JsonField extends JsonNode {
+	String type;
+}

jadx-core/src/main/java/jadx/core/codegen/json/cls/JsonMethod.java

@@ -0,0 +1,51 @@
+package jadx.core.codegen.json.cls;
+
+import java.util.List;
+
+public class JsonMethod extends JsonNode {
+	private String signature;
+	private String returnType;
+	private List<String> arguments;
+	private List<JsonCodeLine> lines;
+	private String offset;
+
+	public String getSignature() {
+		return signature;
+	}
+
+	public void setSignature(String signature) {
+		this.signature = signature;
+	}
+
+	public String getReturnType() {
+		return returnType;
+	}
+
+	public void setReturnType(String returnType) {
+		this.returnType = returnType;
+	}
+
+	public List<String> getArguments() {
+		return arguments;
+	}
+
+	public void setArguments(List<String> arguments) {
+		this.arguments = arguments;
+	}
+
+	public List<JsonCodeLine> getLines() {
+		return lines;
+	}
+
+	public void setLines(List<JsonCodeLine> lines) {
+		this.lines = lines;
+	}
+
+	public String getOffset() {
+		return offset;
+	}
+
+	public void setOffset(String offset) {
+		this.offset = offset;
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/cls/JsonNode.java

@@ -0,0 +1,40 @@
+package jadx.core.codegen.json.cls;
+
+public class JsonNode {
+	private String name;
+	private String alias;
+	private String declaration;
+	private int accessFlags;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
+
+	public void setAlias(String alias) {
+		this.alias = alias;
+	}
+
+	public String getDeclaration() {
+		return declaration;
+	}
+
+	public void setDeclaration(String declaration) {
+		this.declaration = declaration;
+	}
+
+	public int getAccessFlags() {
+		return accessFlags;
+	}
+
+	public void setAccessFlags(int accessFlags) {
+		this.accessFlags = accessFlags;
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/mapping/JsonClsMapping.java

@@ -0,0 +1,71 @@
+package jadx.core.codegen.json.mapping;
+
+import java.util.List;
+
+public class JsonClsMapping {
+	private String name;
+	private String alias;
+
+	private String json;
+	private boolean inner;
+	private String topClass;
+
+	private List<JsonFieldMapping> fields;
+	private List<JsonMthMapping> methods;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
+
+	public void setAlias(String alias) {
+		this.alias = alias;
+	}
+
+	public String getJson() {
+		return json;
+	}
+
+	public void setJson(String json) {
+		this.json = json;
+	}
+
+	public boolean isInner() {
+		return inner;
+	}
+
+	public void setInner(boolean inner) {
+		this.inner = inner;
+	}
+
+	public String getTopClass() {
+		return topClass;
+	}
+
+	public void setTopClass(String topClass) {
+		this.topClass = topClass;
+	}
+
+	public List<JsonFieldMapping> getFields() {
+		return fields;
+	}
+
+	public void setFields(List<JsonFieldMapping> fields) {
+		this.fields = fields;
+	}
+
+	public List<JsonMthMapping> getMethods() {
+		return methods;
+	}
+
+	public void setMethods(List<JsonMthMapping> methods) {
+		this.methods = methods;
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/mapping/JsonFieldMapping.java

@@ -0,0 +1,22 @@
+package jadx.core.codegen.json.mapping;
+
+public class JsonFieldMapping {
+	private String name;
+	private String alias;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
+
+	public void setAlias(String alias) {
+		this.alias = alias;
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/mapping/JsonMapping.java

@@ -0,0 +1,15 @@
+package jadx.core.codegen.json.mapping;
+
+import java.util.List;
+
+public class JsonMapping {
+	private List<JsonClsMapping> classes;
+
+	public List<JsonClsMapping> getClasses() {
+		return classes;
+	}
+
+	public void setClasses(List<JsonClsMapping> classes) {
+		this.classes = classes;
+	}
+}

jadx-core/src/main/java/jadx/core/codegen/json/mapping/JsonMthMapping.java

@@ -0,0 +1,40 @@
+package jadx.core.codegen.json.mapping;
+
+public class JsonMthMapping {
+	private String signature;
+	private String name;
+	private String alias;
+	private String offset;
+
+	public String getSignature() {
+		return signature;
+	}
+
+	public void setSignature(String signature) {
+		this.signature = signature;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
+
+	public void setAlias(String alias) {
+		this.alias = alias;
+	}
+
+	public String getOffset() {
+		return offset;
+	}
+
+	public void setOffset(String offset) {
+		this.offset = offset;
+	}
+}

jadx-core/src/main/java/jadx/core/deobf/DeobfPresets.java

@@ -1,34 +1,37 @@
 package jadx.core.deobf;
 
-import jadx.core.dex.info.ClassInfo;
-import jadx.core.dex.info.FieldInfo;
-import jadx.core.dex.info.MethodInfo;
-
-import java.io.File;
 import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import org.apache.commons.io.FileUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.info.FieldInfo;
+import jadx.core.dex.info.MethodInfo;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
 class DeobfPresets {
 	private static final Logger LOG = LoggerFactory.getLogger(DeobfPresets.class);
 
-	private static final String MAP_FILE_CHARSET = "UTF-8";
+	private static final Charset MAP_FILE_CHARSET = UTF_8;
 
 	private final Deobfuscator deobfuscator;
-	private final File deobfMapFile;
+	private final Path deobfMapFile;
 
-	private final Map<String, String> clsPresetMap = new HashMap<String, String>();
-	private final Map<String, String> fldPresetMap = new HashMap<String, String>();
-	private final Map<String, String> mthPresetMap = new HashMap<String, String>();
+	private final Map<String, String> clsPresetMap = new HashMap<>();
+	private final Map<String, String> fldPresetMap = new HashMap<>();
+	private final Map<String, String> mthPresetMap = new HashMap<>();
 
-	public DeobfPresets(Deobfuscator deobfuscator, File deobfMapFile) {
+	public DeobfPresets(Deobfuscator deobfuscator, Path deobfMapFile) {
 		this.deobfuscator = deobfuscator;
 		this.deobfMapFile = deobfMapFile;
 	}
@@ -37,12 +40,12 @@ class DeobfPresets {
 	 * Loads deobfuscator presets
 	 */
 	public void load() {
-		if (!deobfMapFile.exists()) {
+		if (!Files.exists(deobfMapFile)) {
 			return;
 		}
-		LOG.info("Loading obfuscation map from: {}", deobfMapFile.getAbsoluteFile());
+		LOG.info("Loading obfuscation map from: {}", deobfMapFile.toAbsolutePath());
 		try {
-			List<String> lines = FileUtils.readLines(deobfMapFile, MAP_FILE_CHARSET);
+			List<String> lines = Files.readAllLines(deobfMapFile, MAP_FILE_CHARSET);
 			for (String l : lines) {
 				l = l.trim();
 				if (l.isEmpty() || l.startsWith("#")) {
@@ -65,7 +68,7 @@ class DeobfPresets {
 				}
 			}
 		} catch (IOException e) {
-			LOG.error("Failed to load deobfuscation map file '{}'", deobfMapFile.getAbsolutePath(), e);
+			LOG.error("Failed to load deobfuscation map file '{}'", deobfMapFile.toAbsolutePath(), e);
 		}
 	}
 
@@ -79,18 +82,18 @@ class DeobfPresets {
 
 	public void save(boolean forceSave) {
 		try {
-			if (deobfMapFile.exists()) {
+			if (Files.exists(deobfMapFile)) {
 				if (forceSave) {
 					dumpMapping();
 				} else {
 					LOG.warn("Deobfuscation map file '{}' exists. Use command line option '--deobf-rewrite-cfg' to rewrite it",
-							deobfMapFile.getAbsolutePath());
+							deobfMapFile.toAbsolutePath());
 				}
 			} else {
 				dumpMapping();
 			}
 		} catch (IOException e) {
-			LOG.error("Failed to load deobfuscation map file '{}'", deobfMapFile.getAbsolutePath(), e);
+			LOG.error("Failed to load deobfuscation map file '{}'", deobfMapFile.toAbsolutePath(), e);
 		}
 	}
 
@@ -98,7 +101,7 @@ class DeobfPresets {
 	 * Saves DefaultDeobfuscator presets
 	 */
 	private void dumpMapping() throws IOException {
-		List<String> list = new ArrayList<String>();
+		List<String> list = new ArrayList<>();
 		// packages
 		for (PackageNode p : deobfuscator.getRootPackage().getInnerPackages()) {
 			for (PackageNode pp : p.getInnerPackages()) {
@@ -112,18 +115,20 @@ class DeobfPresets {
 		for (DeobfClsInfo deobfClsInfo : deobfuscator.getClsMap().values()) {
 			if (deobfClsInfo.getAlias() != null) {
 				list.add(String.format("c %s = %s",
-						deobfClsInfo.getCls().getClassInfo().getFullName(), deobfClsInfo.getAlias()));
+						deobfClsInfo.getCls().getClassInfo().makeRawFullName(), deobfClsInfo.getAlias()));
 			}
 		}
 		for (FieldInfo fld : deobfuscator.getFldMap().keySet()) {
-			list.add(String.format("f %s = %s", fld.getFullId(), fld.getAlias()));
+			list.add(String.format("f %s = %s", fld.getRawFullId(), fld.getAlias()));
 		}
 		for (MethodInfo mth : deobfuscator.getMthMap().keySet()) {
-			list.add(String.format("m %s = %s", mth.getFullId(), mth.getAlias()));
+			list.add(String.format("m %s = %s", mth.getRawFullId(), mth.getAlias()));
 		}
 		Collections.sort(list);
-		FileUtils.writeLines(deobfMapFile, MAP_FILE_CHARSET, list);
-		list.clear();
+		Files.write(deobfMapFile, list, MAP_FILE_CHARSET);
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Deobfuscation map file saved as: {}", deobfMapFile);
+		}
 	}
 
 	private static void dfsPackageName(List<String> list, String prefix, PackageNode node) {
@@ -136,15 +141,15 @@ class DeobfPresets {
 	}
 
 	public String getForCls(ClassInfo cls) {
-		return clsPresetMap.get(cls.getFullName());
+		return clsPresetMap.get(cls.makeRawFullName());
 	}
 
 	public String getForFld(FieldInfo fld) {
-		return fldPresetMap.get(fld.getFullId());
+		return fldPresetMap.get(fld.getRawFullId());
 	}
 
 	public String getForMth(MethodInfo mth) {
-		return mthPresetMap.get(mth.getFullId());
+		return mthPresetMap.get(mth.getRawFullId());
 	}
 
 	public void clear() {

jadx-core/src/main/java/jadx/core/deobf/Deobfuscator.java

@@ -1,6 +1,24 @@
 package jadx.core.deobf;
 
-import jadx.api.IJadxArgs;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.SourceFileAttr;
 import jadx.core.dex.info.ClassInfo;
@@ -12,21 +30,6 @@ import jadx.core.dex.nodes.DexNode;
 import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.MethodNode;
 
-import java.io.File;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 public class Deobfuscator {
 	private static final Logger LOG = LoggerFactory.getLogger(Deobfuscator.class);
 
@@ -35,20 +38,21 @@ public class Deobfuscator {
 	public static final String CLASS_NAME_SEPARATOR = ".";
 	public static final String INNER_CLASS_SEPARATOR = "$";
 
-	private final IJadxArgs args;
+	private final JadxArgs args;
 	@NotNull
 	private final List<DexNode> dexNodes;
 	private final DeobfPresets deobfPresets;
 
-	private final Map<ClassInfo, DeobfClsInfo> clsMap = new HashMap<ClassInfo, DeobfClsInfo>();
-	private final Map<FieldInfo, String> fldMap = new HashMap<FieldInfo, String>();
-	private final Map<MethodInfo, String> mthMap = new HashMap<MethodInfo, String>();
+	private final Map<ClassInfo, DeobfClsInfo> clsMap = new LinkedHashMap<>();
+	private final Map<FieldInfo, String> fldMap = new HashMap<>();
+	private final Map<MethodInfo, String> mthMap = new HashMap<>();
 
-	private final Map<MethodInfo, OverridedMethodsNode> ovrdMap = new HashMap<MethodInfo, OverridedMethodsNode>();
-	private final List<OverridedMethodsNode> ovrd = new ArrayList<OverridedMethodsNode>();
+	private final Map<MethodInfo, OverridedMethodsNode> ovrdMap = new HashMap<>();
+	private final List<OverridedMethodsNode> ovrd = new ArrayList<>();
 
 	private final PackageNode rootPackage = new PackageNode("");
-	private final Set<String> pkgSet = new TreeSet<String>();
+	private final Set<String> pkgSet = new TreeSet<>();
+	private final Set<String> reservedClsNames = new HashSet<>();
 
 	private final int maxLength;
 	private final int minLength;
@@ -59,13 +63,13 @@ public class Deobfuscator {
 	private int fldIndex = 0;
 	private int mthIndex = 0;
 
-	public Deobfuscator(IJadxArgs args, @NotNull List<DexNode> dexNodes, File deobfMapFile) {
+	public Deobfuscator(JadxArgs args, @NotNull List<DexNode> dexNodes, Path deobfMapFile) {
 		this.args = args;
 		this.dexNodes = dexNodes;
 
 		this.minLength = args.getDeobfuscationMinLength();
 		this.maxLength = args.getDeobfuscationMaxLength();
-		this.useSourceNameAsAlias = args.useSourceNameAsClassAlias();
+		this.useSourceNameAsAlias = args.isUseSourceNameAsClassAlias();
 
 		this.deobfPresets = new DeobfPresets(this, deobfMapFile);
 	}
@@ -76,8 +80,20 @@ public class Deobfuscator {
 			initIndexes();
 		}
 		process();
+	}
+
+	public void savePresets() {
 		deobfPresets.save(args.isDeobfuscationForceSave());
-		clear();
+	}
+
+	public void clear() {
+		deobfPresets.clear();
+		clsMap.clear();
+		fldMap.clear();
+		mthMap.clear();
+
+		ovrd.clear();
+		ovrdMap.clear();
 	}
 
 	private void initIndexes() {
@@ -90,7 +106,12 @@ public class Deobfuscator {
 	private void preProcess() {
 		for (DexNode dexNode : dexNodes) {
 			for (ClassNode cls : dexNode.getClasses()) {
-				doClass(cls);
+				Collections.addAll(reservedClsNames, cls.getPackage().split("\\."));
+			}
+		}
+		for (DexNode dexNode : dexNodes) {
+			for (ClassNode cls : dexNode.getClasses()) {
+				preProcessClass(cls);
 			}
 		}
 	}
@@ -102,7 +123,7 @@ public class Deobfuscator {
 		}
 		for (DexNode dexNode : dexNodes) {
 			for (ClassNode cls : dexNode.getClasses()) {
-				processClass(dexNode, cls);
+				processClass(cls);
 			}
 		}
 		postProcess();
@@ -111,150 +132,155 @@ public class Deobfuscator {
 	private void postProcess() {
 		int id = 1;
 		for (OverridedMethodsNode o : ovrd) {
-
-			Iterator<MethodInfo> it = o.getMethods().iterator();
-			if (it.hasNext()) {
-				MethodInfo mth = it.next();
-
-				if (mth.isRenamed() && !mth.isAliasFromPreset()) {
-					mth.setAlias(String.format("mo%d%s", id, makeName(mth.getName())));
-				}
-				String firstMethodAlias = mth.getAlias();
-
-				while (it.hasNext()) {
-					mth = it.next();
-					if (!mth.getAlias().equals(firstMethodAlias)) {
-						mth.setAlias(firstMethodAlias);
-					}
+			boolean aliasFromPreset = false;
+			String aliasToUse = null;
+			for (MethodInfo mth : o.getMethods()) {
+				if (mth.isAliasFromPreset()) {
+					aliasToUse = mth.getAlias();
+					aliasFromPreset = true;
 				}
 			}
-
+			for (MethodInfo mth : o.getMethods()) {
+				if (aliasToUse == null) {
+					if (mth.hasAlias() && !mth.isAliasFromPreset()) {
+						mth.setAlias(String.format("mo%d%s", id, prepareNamePart(mth.getName())));
+					}
+					aliasToUse = mth.getAlias();
+				}
+				mth.setAlias(aliasToUse);
+				mth.setAliasFromPreset(aliasFromPreset);
+			}
 			id++;
 		}
 	}
 
-	void clear() {
-		deobfPresets.clear();
-		clsMap.clear();
-		fldMap.clear();
-		mthMap.clear();
+	private void resolveOverriding(MethodNode mth) {
+		Set<ClassNode> clsParents = new LinkedHashSet<>();
+		collectClassHierarchy(mth.getParentClass(), clsParents);
 
-		ovrd.clear();
-		ovrdMap.clear();
-	}
-
-	@Nullable
-	private static ClassNode resolveOverridingInternal(DexNode dex, ClassNode cls, String signature,
-			Set<MethodInfo> overrideSet, ClassNode rootClass) {
-		ClassNode result = null;
-
-		for (MethodNode m : cls.getMethods()) {
-			if (m.getMethodInfo().getShortId().startsWith(signature)) {
-				result = cls;
-				if (!overrideSet.contains(m.getMethodInfo())) {
-					overrideSet.add(m.getMethodInfo());
-				}
-				break;
+		String mthSignature = mth.getMethodInfo().makeSignature(false);
+		Set<MethodInfo> overrideSet = new LinkedHashSet<>();
+		for (ClassNode classNode : clsParents) {
+			MethodInfo methodInfo = getMthOverride(classNode.getMethods(), mthSignature);
+			if (methodInfo != null) {
+				overrideSet.add(methodInfo);
 			}
 		}
-
-		ArgType superClass = cls.getSuperClass();
-		if (superClass != null) {
-			ClassNode superNode = dex.resolveClass(superClass);
-			if (superNode != null) {
-				ClassNode clsWithMth = resolveOverridingInternal(dex, superNode, signature, overrideSet, rootClass);
-				if (clsWithMth != null) {
-					if ((result != null) && (result != cls)) {
-						if (clsWithMth != result) {
-							LOG.warn(String.format("Multiple overriding '%s' from '%s' and '%s' in '%s'",
-									signature,
-									result.getFullName(), clsWithMth.getFullName(),
-									rootClass.getFullName()));
-						}
-					} else {
-						result = clsWithMth;
-					}
-				}
-			}
+		if (overrideSet.isEmpty()) {
+			return;
 		}
-
-		for (ArgType iFaceType : cls.getInterfaces()) {
-			ClassNode iFaceNode = dex.resolveClass(iFaceType);
-			if (iFaceNode != null) {
-				ClassNode clsWithMth = resolveOverridingInternal(dex, iFaceNode, signature, overrideSet, rootClass);
-				if (clsWithMth != null) {
-					if ((result != null) && (result != cls)) {
-						if (clsWithMth != result) {
-							LOG.warn(String.format("Multiple overriding '%s' from '%s' and '%s' in '%s'",
-									signature,
-									result.getFullName(), clsWithMth.getFullName(),
-									rootClass.getFullName()));
-						}
-					} else {
-						result = clsWithMth;
-					}
-				}
-			}
+		OverridedMethodsNode overrideNode = getOverrideMethodsNode(overrideSet);
+		if (overrideNode == null) {
+			overrideNode = new OverridedMethodsNode(overrideSet);
+			ovrd.add(overrideNode);
 		}
-
-		return result;
-	}
-
-	private void resolveOverriding(DexNode dex, ClassNode cls, MethodNode mth) {
-		Set<MethodInfo> overrideSet = new HashSet<MethodInfo>();
-		resolveOverridingInternal(dex, cls, mth.getMethodInfo().makeSignature(false), overrideSet, cls);
-
-		if (overrideSet.size() > 1) {
-			OverridedMethodsNode overrideNode = null;
-			for (MethodInfo _mth : overrideSet) {
-				if (ovrdMap.containsKey(_mth)) {
-					overrideNode = ovrdMap.get(_mth);
-					break;
-				}
+		for (MethodInfo overrideMth : overrideSet) {
+			if (!ovrdMap.containsKey(overrideMth)) {
+				ovrdMap.put(overrideMth, overrideNode);
+				overrideNode.add(overrideMth);
 			}
-
-			if (overrideNode == null) {
-				overrideNode = new OverridedMethodsNode(overrideSet);
-				ovrd.add(overrideNode);
-			}
-
-			for (MethodInfo _mth : overrideSet) {
-				if (!ovrdMap.containsKey(_mth)) {
-					ovrdMap.put(_mth, overrideNode);
-					if (!overrideNode.contains(_mth)) {
-						overrideNode.add(_mth);
-					}
-				}
-			}
-		} else {
-			overrideSet.clear();
-			overrideSet = null;
 		}
 	}
 
-	private void processClass(DexNode dex, ClassNode cls) {
+	private OverridedMethodsNode getOverrideMethodsNode(Set<MethodInfo> overrideSet) {
+		for (MethodInfo overrideMth : overrideSet) {
+			OverridedMethodsNode node = ovrdMap.get(overrideMth);
+			if (node != null) {
+				return node;
+			}
+		}
+		return null;
+	}
+
+	private MethodInfo getMthOverride(List<MethodNode> methods, String mthSignature) {
+		for (MethodNode m : methods) {
+			MethodInfo mthInfo = m.getMethodInfo();
+			if (mthInfo.getShortId().startsWith(mthSignature)) {
+				return mthInfo;
+			}
+		}
+		return null;
+	}
+
+	private void collectClassHierarchy(ClassNode cls, Set<ClassNode> collected) {
+		boolean added = collected.add(cls);
+		if (added) {
+			ArgType superClass = cls.getSuperClass();
+			if (superClass != null) {
+				ClassNode superNode = cls.dex().resolveClass(superClass);
+				if (superNode != null) {
+					collectClassHierarchy(superNode, collected);
+				}
+			}
+
+			for (ArgType argType : cls.getInterfaces()) {
+				ClassNode interfaceNode = cls.dex().resolveClass(argType);
+				if (interfaceNode != null) {
+					collectClassHierarchy(interfaceNode, collected);
+				}
+			}
+		}
+	}
+
+	private void processClass(ClassNode cls) {
+		if (isR(cls.getParentClass())) {
+			return;
+		}
 		ClassInfo clsInfo = cls.getClassInfo();
-		String fullName = getClassFullName(clsInfo);
-		if (!fullName.equals(clsInfo.getFullName())) {
-			clsInfo.rename(dex, fullName);
+		DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
+		if (deobfClsInfo != null) {
+			clsInfo.changeShortName(deobfClsInfo.getAlias());
+			PackageNode pkgNode = deobfClsInfo.getPkg();
+			if (!clsInfo.isInner() && pkgNode.hasAnyAlias()) {
+				clsInfo.changePkg(pkgNode.getFullAlias());
+			}
+		} else if (!clsInfo.isInner()) {
+			// check if package renamed
+			PackageNode pkgNode = getPackageNode(clsInfo.getPackage(), false);
+			if (pkgNode != null && pkgNode.hasAnyAlias()) {
+				clsInfo.changePkg(pkgNode.getFullAlias());
+			}
 		}
 		for (FieldNode field : cls.getFields()) {
-			FieldInfo fieldInfo = field.getFieldInfo();
-			String alias = getFieldAlias(field);
-			if (alias != null) {
-				fieldInfo.setAlias(alias);
+			if (field.contains(AFlag.DONT_RENAME)) {
+				continue;
 			}
+			renameField(field);
 		}
 		for (MethodNode mth : cls.getMethods()) {
-			MethodInfo methodInfo = mth.getMethodInfo();
-			String alias = getMethodAlias(mth);
-			if (alias != null) {
-				methodInfo.setAlias(alias);
-			}
+			renameMethod(mth);
+		}
+		for (ClassNode innerCls : cls.getInnerClasses()) {
+			processClass(innerCls);
+		}
+	}
 
-			if (mth.isVirtual()) {
-				resolveOverriding(dex, cls, mth);
-			}
+	private void renameField(FieldNode field) {
+		FieldInfo fieldInfo = field.getFieldInfo();
+		String alias = getFieldAlias(field);
+		if (alias != null) {
+			fieldInfo.setAlias(alias);
+		}
+	}
+
+	public void forceRenameField(FieldNode field) {
+		field.getFieldInfo().setAlias(makeFieldAlias(field));
+	}
+
+	private void renameMethod(MethodNode mth) {
+		String alias = getMethodAlias(mth);
+		if (alias != null) {
+			mth.getMethodInfo().setAlias(alias);
+		}
+		if (mth.isVirtual()) {
+			resolveOverriding(mth);
+		}
+	}
+
+	public void forceRenameMethod(MethodNode mth) {
+		mth.getMethodInfo().setAlias(makeMethodAlias(mth));
+		if (mth.isVirtual()) {
+			resolveOverriding(mth);
 		}
 	}
 
@@ -268,7 +294,8 @@ public class Deobfuscator {
 	 *
 	 * @param fullPkgName full package name
 	 * @param create      if {@code true} then will create all absent objects
-	 * @return package node object or {@code null} if no package found and <b>create</b> set to {@code false}
+	 * @return package node object or {@code null} if no package found and <b>create</b> set to
+	 *         {@code false}
 	 */
 	private PackageNode getPackageNode(String fullPkgName, boolean create) {
 		if (fullPkgName.isEmpty() || fullPkgName.equals(CLASS_NAME_SEPARATOR)) {
@@ -315,22 +342,25 @@ public class Deobfuscator {
 		return prefix + clsInfo.getShortName();
 	}
 
-	private void doClass(ClassNode cls) {
+	private void preProcessClass(ClassNode cls) {
 		ClassInfo classInfo = cls.getClassInfo();
 		String pkgFullName = classInfo.getPackage();
 		PackageNode pkg = getPackageNode(pkgFullName, true);
-		doPkg(pkg, pkgFullName);
+		processPackageFull(pkg, pkgFullName);
 
 		String alias = deobfPresets.getForCls(classInfo);
 		if (alias != null) {
 			clsMap.put(classInfo, new DeobfClsInfo(this, cls, pkg, alias));
-			return;
+		} else {
+			if (!clsMap.containsKey(classInfo)) {
+				String clsShortName = classInfo.getShortName();
+				if (shouldRename(clsShortName) || reservedClsNames.contains(clsShortName)) {
+					makeClsAlias(cls);
+				}
+			}
 		}
-		if (clsMap.containsKey(classInfo)) {
-			return;
-		}
-		if (shouldRename(classInfo.getShortName())) {
-			makeClsAlias(cls);
+		for (ClassNode innerCls : cls.getInnerClasses()) {
+			preProcessClass(innerCls);
 		}
 	}
 
@@ -342,6 +372,24 @@ public class Deobfuscator {
 		return makeClsAlias(cls);
 	}
 
+	public String getPkgAlias(ClassNode cls) {
+		ClassInfo classInfo = cls.getClassInfo();
+		PackageNode pkg = null;
+		DeobfClsInfo deobfClsInfo = clsMap.get(classInfo);
+		if (deobfClsInfo != null) {
+			pkg = deobfClsInfo.getPkg();
+		} else {
+			String fullPkgName = classInfo.getPackage();
+			pkg = getPackageNode(fullPkgName, true);
+			processPackageFull(pkg, fullPkgName);
+		}
+		if (pkg.hasAnyAlias()) {
+			return pkg.getFullAlias();
+		} else {
+			return pkg.getFullName();
+		}
+	}
+
 	private String makeClsAlias(ClassNode cls) {
 		ClassInfo classInfo = cls.getClassInfo();
 		String alias = null;
@@ -352,7 +400,7 @@ public class Deobfuscator {
 
 		if (alias == null) {
 			String clsName = classInfo.getShortName();
-			alias = String.format("C%04d%s", clsIndex++, makeName(clsName));
+			alias = String.format("C%04d%s", clsIndex++, prepareNamePart(clsName));
 		}
 		PackageNode pkg = getPackageNode(classInfo.getPackage(), true);
 		clsMap.put(classInfo, new DeobfClsInfo(this, cls, pkg, alias));
@@ -365,21 +413,33 @@ public class Deobfuscator {
 		if (sourceFileAttr == null) {
 			return null;
 		}
+		if (cls.getClassInfo().isInner()) {
+			return null;
+		}
 		String name = sourceFileAttr.getFileName();
 		if (name.endsWith(".java")) {
 			name = name.substring(0, name.length() - ".java".length());
+		} else if (name.endsWith(".kt")) {
+			name = name.substring(0, name.length() - ".kt".length());
 		}
-		if (NameMapper.isValidIdentifier(name)
-				&& !NameMapper.isReserved(name)) {
-			// TODO: check if no class with this name exists or already renamed
-			cls.remove(AType.SOURCE_FILE);
-			return name;
+		if (!NameMapper.isValidAndPrintable(name)) {
+			return null;
 		}
-		return null;
+		for (DeobfClsInfo deobfClsInfo : clsMap.values()) {
+			if (deobfClsInfo.getAlias().equals(name)) {
+				return null;
+			}
+		}
+		ClassNode otherCls = cls.root().searchClassByName(cls.getPackage() + '.' + name);
+		if (otherCls != null) {
+			return null;
+		}
+		cls.remove(AType.SOURCE_FILE);
+		return name;
 	}
 
 	@Nullable
-	public String getFieldAlias(FieldNode field) {
+	private String getFieldAlias(FieldNode field) {
 		FieldInfo fieldInfo = field.getFieldInfo();
 		String alias = fldMap.get(fieldInfo);
 		if (alias != null) {
@@ -397,8 +457,11 @@ public class Deobfuscator {
 	}
 
 	@Nullable
-	public String getMethodAlias(MethodNode mth) {
+	private String getMethodAlias(MethodNode mth) {
 		MethodInfo methodInfo = mth.getMethodInfo();
+		if (methodInfo.isClassInit() || methodInfo.isConstructor()) {
+			return null;
+		}
 		String alias = mthMap.get(methodInfo);
 		if (alias != null) {
 			return alias;
@@ -416,18 +479,18 @@ public class Deobfuscator {
 	}
 
 	public String makeFieldAlias(FieldNode field) {
-		String alias = String.format("f%d%s", fldIndex++, makeName(field.getName()));
+		String alias = String.format("f%d%s", fldIndex++, prepareNamePart(field.getName()));
 		fldMap.put(field.getFieldInfo(), alias);
 		return alias;
 	}
 
 	public String makeMethodAlias(MethodNode mth) {
-		String alias = String.format("m%d%s", mthIndex++, makeName(mth.getName()));
+		String alias = String.format("m%d%s", mthIndex++, prepareNamePart(mth.getName()));
 		mthMap.put(mth.getMethodInfo(), alias);
 		return alias;
 	}
 
-	private void doPkg(PackageNode pkg, String fullName) {
+	private void processPackageFull(PackageNode pkg, String fullName) {
 		if (pkgSet.contains(fullName)) {
 			return;
 		}
@@ -437,47 +500,32 @@ public class Deobfuscator {
 		PackageNode parentPkg = pkg.getParentPackage();
 		while (!parentPkg.getName().isEmpty()) {
 			if (!parentPkg.hasAlias()) {
-				doPkg(parentPkg, parentPkg.getFullName());
+				processPackageFull(parentPkg, parentPkg.getFullName());
 			}
 			parentPkg = parentPkg.getParentPackage();
 		}
 
-		final String pkgName = pkg.getName();
-		if (!pkg.hasAlias() && shouldRename(pkgName)) {
-			final String pkgAlias = String.format("p%03d%s", pkgIndex++, makeName(pkgName));
-			pkg.setAlias(pkgAlias);
+		if (!pkg.hasAlias()) {
+			String pkgName = pkg.getName();
+			if ((args.isDeobfuscationOn() && shouldRename(pkgName))
+					|| (args.isRenameValid() && !NameMapper.isValidIdentifier(pkgName))
+					|| (args.isRenamePrintable() && !NameMapper.isAllCharsPrintable(pkgName))) {
+				String pkgAlias = String.format("p%03d%s", pkgIndex++, prepareNamePart(pkg.getName()));
+				pkg.setAlias(pkgAlias);
+			}
 		}
 	}
 
 	private boolean shouldRename(String s) {
-		return s.length() > maxLength
-				|| s.length() < minLength
-				|| NameMapper.isReserved(s)
-				|| !NameMapper.isAllCharsPrintable(s);
+		int len = s.length();
+		return len < minLength || len > maxLength;
 	}
 
-	private String makeName(String name) {
+	private String prepareNamePart(String name) {
 		if (name.length() > maxLength) {
-			return "x" + Integer.toHexString(name.hashCode());
+			return 'x' + Integer.toHexString(name.hashCode());
 		}
-		if (NameMapper.isReserved(name)) {
-			return name;
-		}
-		if (!NameMapper.isAllCharsPrintable(name)) {
-			return removeInvalidChars(name);
-		}
-		return name;
-	}
-
-	private String removeInvalidChars(String name) {
-		StringBuilder sb = new StringBuilder();
-		for (int i = 0; i < name.length(); i++) {
-			int ch = name.charAt(i);
-			if (NameMapper.isPrintableChar(ch)) {
-				sb.append((char) ch);
-			}
-		}
-		return sb.toString();
+		return NameMapper.removeInvalidCharsMiddle(name);
 	}
 
 	private void dumpClassAlias(ClassNode cls) {
@@ -501,7 +549,7 @@ public class Deobfuscator {
 	}
 
 	private String getPackageName(String packageName) {
-		final PackageNode pkg = getPackageNode(packageName, false);
+		PackageNode pkg = getPackageNode(packageName, false);
 		if (pkg != null) {
 			return pkg.getFullAlias();
 		}
@@ -509,7 +557,7 @@ public class Deobfuscator {
 	}
 
 	private String getClassName(ClassInfo clsInfo) {
-		final DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
+		DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
 		if (deobfClsInfo != null) {
 			return deobfClsInfo.makeNameWithoutPkg();
 		}
@@ -517,11 +565,8 @@ public class Deobfuscator {
 	}
 
 	private String getClassFullName(ClassNode cls) {
-		return getClassFullName(cls.getClassInfo());
-	}
-
-	private String getClassFullName(ClassInfo clsInfo) {
-		final DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
+		ClassInfo clsInfo = cls.getClassInfo();
+		DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
 		if (deobfClsInfo != null) {
 			return deobfClsInfo.getFullName();
 		}
@@ -543,4 +588,27 @@ public class Deobfuscator {
 	public PackageNode getRootPackage() {
 		return rootPackage;
 	}
+
+	private static boolean isR(ClassNode cls) {
+		if (!cls.getClassInfo().getShortName().equals("R")) {
+			return false;
+		}
+		if (!cls.getMethods().isEmpty() || !cls.getFields().isEmpty()) {
+			return false;
+		}
+		for (ClassNode inner : cls.getInnerClasses()) {
+			for (MethodNode m : inner.getMethods()) {
+				if (!m.getMethodInfo().isConstructor() && !m.getMethodInfo().isClassInit()) {
+					return false;
+				}
+			}
+			for (FieldNode field : cls.getFields()) {
+				ArgType type = field.getType();
+				if (type != ArgType.INT && (!type.isArray() || type.getArrayElement() != ArgType.INT)) {
+					return false;
+				}
+			}
+		}
+		return true;
+	}
 }

jadx-core/src/main/java/jadx/core/deobf/NameMapper.java

@@ -5,6 +5,8 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.regex.Pattern;
 
+import static jadx.core.utils.StringUtils.notEmpty;
+
 public class NameMapper {
 
 	private static final Pattern VALID_JAVA_IDENTIFIER = Pattern.compile(
@@ -13,8 +15,8 @@ public class NameMapper {
 	private static final Pattern VALID_JAVA_FULL_IDENTIFIER = Pattern.compile(
 			"(" + VALID_JAVA_IDENTIFIER + "\\.)*" + VALID_JAVA_IDENTIFIER);
 
-	private static final Set<String> RESERVED_NAMES = new HashSet<String>(
-			Arrays.asList(new String[]{
+	private static final Set<String> RESERVED_NAMES = new HashSet<>(
+			Arrays.asList(
 					"abstract",
 					"assert",
 					"boolean",
@@ -67,20 +69,34 @@ public class NameMapper {
 					"try",
 					"void",
 					"volatile",
-					"while",
-			})
-	);
+					"while"));
 
 	public static boolean isReserved(String str) {
 		return RESERVED_NAMES.contains(str);
 	}
 
 	public static boolean isValidIdentifier(String str) {
-		return VALID_JAVA_IDENTIFIER.matcher(str).matches() && isAllCharsPrintable(str);
+		return notEmpty(str)
+				&& !isReserved(str)
+				&& VALID_JAVA_IDENTIFIER.matcher(str).matches();
 	}
 
 	public static boolean isValidFullIdentifier(String str) {
-		return VALID_JAVA_FULL_IDENTIFIER.matcher(str).matches() && isAllCharsPrintable(str);
+		return notEmpty(str)
+				&& !isReserved(str)
+				&& VALID_JAVA_FULL_IDENTIFIER.matcher(str).matches();
+	}
+
+	public static boolean isValidAndPrintable(String str) {
+		return isValidIdentifier(str) && isAllCharsPrintable(str);
+	}
+
+	public static boolean isValidIdentifierStart(int codePoint) {
+		return Character.isJavaIdentifierStart(codePoint);
+	}
+
+	public static boolean isValidIdentifierPart(int codePoint) {
+		return Character.isJavaIdentifierPart(codePoint);
 	}
 
 	public static boolean isPrintableChar(int c) {
@@ -96,4 +112,54 @@ public class NameMapper {
 		}
 		return true;
 	}
+
+	/**
+	 * Return modified string with removed:
+	 * <p>
+	 * <ul>
+	 * <li>not printable chars (including unicode)
+	 * <li>chars not valid for java identifier part
+	 * </ul>
+	 * <p>
+	 * Note: this 'middle' method must be used with prefixed string:
+	 * <p>
+	 * <ul>
+	 * <li>can leave invalid chars for java identifier start (i.e numbers)
+	 * <li>result not checked for reserved words
+	 * </ul>
+	 * <p>
+	 */
+	public static String removeInvalidCharsMiddle(String name) {
+		if (isValidIdentifier(name) && isAllCharsPrintable(name)) {
+			return name;
+		}
+		int len = name.length();
+		StringBuilder sb = new StringBuilder(len);
+		for (int i = 0; i < len; i++) {
+			int codePoint = name.codePointAt(i);
+			if (isPrintableChar(codePoint) && isValidIdentifierPart(codePoint)) {
+				sb.append((char) codePoint);
+			}
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * Return string with removed invalid chars, see {@link #removeInvalidCharsMiddle}
+	 * <p>
+	 * Prepend prefix if first char is not valid as java identifier start char.
+	 */
+	public static String removeInvalidChars(String name, String prefix) {
+		String result = removeInvalidCharsMiddle(name);
+		if (!result.isEmpty()) {
+			int codePoint = result.codePointAt(0);
+			if (!isValidIdentifierStart(codePoint)) {
+				return prefix + result;
+			}
+		}
+		return result;
+	}
+
+	private NameMapper() {
+	}
 }

jadx-core/src/main/java/jadx/core/deobf/OverridedMethodsNode.java

@@ -1,10 +1,10 @@
 package jadx.core.deobf;
 
-import jadx.core.dex.info.MethodInfo;
-
 import java.util.Set;
 
-/* package */ class OverridedMethodsNode {
+import jadx.core.dex.info.MethodInfo;
+
+class OverridedMethodsNode {
 
 	private Set<MethodInfo> methods;
 

jadx-core/src/main/java/jadx/core/deobf/PackageNode.java

@@ -1,9 +1,10 @@
 package jadx.core.deobf;
 
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Deque;
 import java.util.List;
-import java.util.Stack;
 
 public class PackageNode {
 
@@ -29,11 +30,11 @@ public class PackageNode {
 
 	public String getFullName() {
 		if (cachedPackageFullName == null) {
-			Stack<PackageNode> pp = getParentPackages();
+			Deque<PackageNode> pp = getParentPackages();
 
 			StringBuilder result = new StringBuilder();
 			result.append(pp.pop().getName());
-			while (pp.size() > 0) {
+			while (!pp.isEmpty()) {
 				result.append(SEPARATOR_CHAR);
 				result.append(pp.pop().getName());
 			}
@@ -57,14 +58,24 @@ public class PackageNode {
 		return packageAlias != null;
 	}
 
+	public boolean hasAnyAlias() {
+		if (hasAlias()) {
+			return true;
+		}
+		if (parentPackage != this) {
+			return parentPackage.hasAnyAlias();
+		}
+		return false;
+	}
+
 	public String getFullAlias() {
 		if (cachedPackageFullAlias == null) {
-			Stack<PackageNode> pp = getParentPackages();
+			Deque<PackageNode> pp = getParentPackages();
 			StringBuilder result = new StringBuilder();
 
-			if (pp.size() > 0) {
+			if (!pp.isEmpty()) {
 				result.append(pp.pop().getAlias());
-				while (pp.size() > 0) {
+				while (!pp.isEmpty()) {
 					result.append(SEPARATOR_CHAR);
 					result.append(pp.pop().getAlias());
 				}
@@ -86,7 +97,7 @@ public class PackageNode {
 
 	public void addInnerPackage(PackageNode pkg) {
 		if (innerPackages.isEmpty()) {
-			innerPackages = new ArrayList<PackageNode>();
+			innerPackages = new ArrayList<>();
 		}
 		innerPackages.add(pkg);
 		pkg.parentPackage = this;
@@ -114,17 +125,21 @@ public class PackageNode {
 	 *
 	 * @return stack with parent packages
 	 */
-	private Stack<PackageNode> getParentPackages() {
-		Stack<PackageNode> pp = new Stack<PackageNode>();
+	private Deque<PackageNode> getParentPackages() {
+		Deque<PackageNode> pp = new ArrayDeque<>();
 
-		PackageNode currentP = this;
-		PackageNode parentP = currentP.getParentPackage();
-
-		while (currentP != parentP) {
-			pp.push(currentP);
-			currentP = parentP;
-			parentP = currentP.getParentPackage();
+		PackageNode currentPkg = this;
+		PackageNode parentPkg = currentPkg.getParentPackage();
+		while (currentPkg != parentPkg) {
+			pp.push(currentPkg);
+			currentPkg = parentPkg;
+			parentPkg = currentPkg.getParentPackage();
 		}
 		return pp;
 	}
+
+	@Override
+	public String toString() {
+		return packageAlias;
+	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AFlag.java

@@ -1,6 +1,7 @@
 package jadx.core.dex.attributes;
 
 public enum AFlag {
+	MTH_ENTER_BLOCK,
 	TRY_ENTER,
 	TRY_LEAVE,
 
@@ -8,25 +9,49 @@ public enum AFlag {
 	LOOP_END,
 
 	SYNTHETIC,
-	FINAL, // SSAVar attribute for make var final
 
 	RETURN, // block contains only return instruction
 	ORIG_RETURN,
 
-	DECLARE_VAR,
 	DONT_WRAP,
-
-	DONT_SHRINK,
 	DONT_INLINE,
-	DONT_GENERATE,
-	SKIP,
-	REMOVE,
+	DONT_GENERATE, // process as usual, but don't output to generated code
+	COMMENT_OUT, // process as usual, but comment insn in generated code
+	REMOVE, // can be completely removed
+
+	HIDDEN, // instruction used inside other instruction but not listed in args
+
+	RESTART_CODEGEN,
+	DONT_RENAME, // do not rename during deobfuscation
+	ADDED_TO_REGION,
+
+	FINALLY_INSNS,
 
 	SKIP_FIRST_ARG,
 	SKIP_ARG, // skip argument in invoke call
 	ANONYMOUS_CONSTRUCTOR,
 	ANONYMOUS_CLASS,
 
+	THIS,
+
+	/**
+	 * RegisterArg attribute for method arguments
+	 */
+	METHOD_ARGUMENT,
+
+	/**
+	 * Type of RegisterArg or SSAVar can't be changed
+	 */
+	IMMUTABLE_TYPE,
+
+	/**
+	 * Force inline instruction with inline assign
+	 */
+	FORCE_ASSIGN_INLINE,
+
+	CUSTOM_DECLARE, // variable for this register don't need declaration
+	DECLARE_VAR,
+
 	ELSE_IF_CHAIN,
 
 	WRAPPED,
@@ -34,5 +59,13 @@ public enum AFlag {
 
 	FALL_THROUGH,
 
+	EXPLICIT_GENERICS,
+
+	/**
+	 * Use constants with explicit type: cast '(byte) 1' or type letter '7L'
+	 */
+	EXPLICIT_PRIMITIVE_TYPE,
+	EXPLICIT_CAST,
+
 	INCONSISTENT_CODE, // warning about incorrect decompilation
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AType.java

@@ -1,5 +1,9 @@
 package jadx.core.dex.attributes;
 
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
 import jadx.core.dex.attributes.annotations.AnnotationsList;
 import jadx.core.dex.attributes.annotations.MethodParameters;
 import jadx.core.dex.attributes.nodes.DeclareVariablesAttr;
@@ -9,12 +13,16 @@ import jadx.core.dex.attributes.nodes.EnumMapAttr;
 import jadx.core.dex.attributes.nodes.FieldReplaceAttr;
 import jadx.core.dex.attributes.nodes.ForceReturnAttr;
 import jadx.core.dex.attributes.nodes.IgnoreEdgeAttr;
-import jadx.core.dex.attributes.nodes.JadxErrorAttr;
+import jadx.core.dex.attributes.nodes.JadxError;
 import jadx.core.dex.attributes.nodes.JumpInfo;
+import jadx.core.dex.attributes.nodes.LocalVarsDebugInfoAttr;
 import jadx.core.dex.attributes.nodes.LoopInfo;
 import jadx.core.dex.attributes.nodes.LoopLabelAttr;
 import jadx.core.dex.attributes.nodes.MethodInlineAttr;
 import jadx.core.dex.attributes.nodes.PhiListAttr;
+import jadx.core.dex.attributes.nodes.RegDebugInfoAttr;
+import jadx.core.dex.attributes.nodes.RenameReasonAttr;
+import jadx.core.dex.attributes.nodes.SkipMethodArgsAttr;
 import jadx.core.dex.attributes.nodes.SourceFileAttr;
 import jadx.core.dex.nodes.parser.FieldInitAttr;
 import jadx.core.dex.trycatch.CatchAttr;
@@ -29,25 +37,54 @@ import jadx.core.dex.trycatch.SplitterBlockAttr;
  */
 public class AType<T extends IAttribute> {
 
-	public static final AType<AttrList<JumpInfo>> JUMP = new AType<AttrList<JumpInfo>>();
-	public static final AType<AttrList<LoopInfo>> LOOP = new AType<AttrList<LoopInfo>>();
-	public static final AType<AttrList<EdgeInsnAttr>> EDGE_INSN = new AType<AttrList<EdgeInsnAttr>>();
+	// class, method, field
+	public static final AType<AnnotationsList> ANNOTATION_LIST = new AType<>();
+	public static final AType<RenameReasonAttr> RENAME_REASON = new AType<>();
 
-	public static final AType<ExcHandlerAttr> EXC_HANDLER = new AType<ExcHandlerAttr>();
-	public static final AType<CatchAttr> CATCH_BLOCK = new AType<CatchAttr>();
-	public static final AType<SplitterBlockAttr> SPLITTER_BLOCK = new AType<SplitterBlockAttr>();
-	public static final AType<ForceReturnAttr> FORCE_RETURN = new AType<ForceReturnAttr>();
-	public static final AType<FieldInitAttr> FIELD_INIT = new AType<FieldInitAttr>();
-	public static final AType<FieldReplaceAttr> FIELD_REPLACE = new AType<FieldReplaceAttr>();
-	public static final AType<JadxErrorAttr> JADX_ERROR = new AType<JadxErrorAttr>();
-	public static final AType<MethodInlineAttr> METHOD_INLINE = new AType<MethodInlineAttr>();
-	public static final AType<EnumClassAttr> ENUM_CLASS = new AType<EnumClassAttr>();
-	public static final AType<EnumMapAttr> ENUM_MAP = new AType<EnumMapAttr>();
-	public static final AType<AnnotationsList> ANNOTATION_LIST = new AType<AnnotationsList>();
-	public static final AType<MethodParameters> ANNOTATION_MTH_PARAMETERS = new AType<MethodParameters>();
-	public static final AType<PhiListAttr> PHI_LIST = new AType<PhiListAttr>();
-	public static final AType<SourceFileAttr> SOURCE_FILE = new AType<SourceFileAttr>();
-	public static final AType<DeclareVariablesAttr> DECLARE_VARIABLES = new AType<DeclareVariablesAttr>();
-	public static final AType<LoopLabelAttr> LOOP_LABEL = new AType<LoopLabelAttr>();
-	public static final AType<IgnoreEdgeAttr> IGNORE_EDGE = new AType<IgnoreEdgeAttr>();
+	// class, method
+	public static final AType<AttrList<JadxError>> JADX_ERROR = new AType<>(); // code failed to decompile completely
+	public static final AType<AttrList<String>> JADX_WARN = new AType<>(); // mark code as inconsistent (code can be viewed)
+	public static final AType<AttrList<String>> COMMENTS = new AType<>(); // any additional info about decompilation
+
+	// class
+	public static final AType<SourceFileAttr> SOURCE_FILE = new AType<>();
+	public static final AType<EnumClassAttr> ENUM_CLASS = new AType<>();
+	public static final AType<EnumMapAttr> ENUM_MAP = new AType<>();
+
+	// field
+	public static final AType<FieldInitAttr> FIELD_INIT = new AType<>();
+	public static final AType<FieldReplaceAttr> FIELD_REPLACE = new AType<>();
+
+	// method
+	public static final AType<LocalVarsDebugInfoAttr> LOCAL_VARS_DEBUG_INFO = new AType<>();
+	public static final AType<MethodInlineAttr> METHOD_INLINE = new AType<>();
+	public static final AType<MethodParameters> ANNOTATION_MTH_PARAMETERS = new AType<>();
+	public static final AType<SkipMethodArgsAttr> SKIP_MTH_ARGS = new AType<>();
+
+	// region
+	public static final AType<DeclareVariablesAttr> DECLARE_VARIABLES = new AType<>();
+
+	// block
+	public static final AType<PhiListAttr> PHI_LIST = new AType<>();
+	public static final AType<IgnoreEdgeAttr> IGNORE_EDGE = new AType<>();
+	public static final AType<ForceReturnAttr> FORCE_RETURN = new AType<>();
+	public static final AType<CatchAttr> CATCH_BLOCK = new AType<>();
+	public static final AType<SplitterBlockAttr> SPLITTER_BLOCK = new AType<>();
+	public static final AType<AttrList<LoopInfo>> LOOP = new AType<>();
+	public static final AType<AttrList<EdgeInsnAttr>> EDGE_INSN = new AType<>();
+
+	// block or insn
+	public static final AType<ExcHandlerAttr> EXC_HANDLER = new AType<>();
+
+	// instruction
+	public static final AType<LoopLabelAttr> LOOP_LABEL = new AType<>();
+	public static final AType<AttrList<JumpInfo>> JUMP = new AType<>();
+
+	// register
+	public static final AType<RegDebugInfoAttr> REG_DEBUG_INFO = new AType<>();
+
+	public static final Set<AType<?>> SKIP_ON_UNLOAD = new HashSet<>(Arrays.asList(
+			FIELD_REPLACE,
+			METHOD_INLINE,
+			SKIP_MTH_ARGS));
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AttrList.java

@@ -1,14 +1,14 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.utils.Utils;
-
-import java.util.LinkedList;
+import java.util.ArrayList;
 import java.util.List;
 
+import jadx.core.utils.Utils;
+
 public class AttrList<T> implements IAttribute {
 
 	private final AType<AttrList<T>> type;
-	private final List<T> list = new LinkedList<T>();
+	private final List<T> list = new ArrayList<>();
 
 	public AttrList(AType<AttrList<T>> type) {
 		this.type = type;
@@ -25,6 +25,6 @@ public class AttrList<T> implements IAttribute {
 
 	@Override
 	public String toString() {
-		return Utils.listToString(list);
+		return Utils.listToString(list, "\n");
 	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AttrNode.java

@@ -1,9 +1,9 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.dex.attributes.annotations.Annotation;
-
 import java.util.List;
 
+import jadx.core.dex.attributes.annotations.Annotation;
+
 public abstract class AttrNode implements IAttributeNode {
 
 	private static final AttributeStorage EMPTY_ATTR_STORAGE = new EmptyAttrStorage();
@@ -42,6 +42,12 @@ public abstract class AttrNode implements IAttributeNode {
 		return store;
 	}
 
+	private void unloadIfEmpty() {
+		if (storage.isEmpty() && storage != EMPTY_ATTR_STORAGE) {
+			storage = EMPTY_ATTR_STORAGE;
+		}
+	}
+
 	@Override
 	public boolean contains(AFlag flag) {
 		return storage.contains(flag);
@@ -70,21 +76,36 @@ public abstract class AttrNode implements IAttributeNode {
 	@Override
 	public void remove(AFlag flag) {
 		storage.remove(flag);
+		unloadIfEmpty();
 	}
 
 	@Override
 	public <T extends IAttribute> void remove(AType<T> type) {
 		storage.remove(type);
+		unloadIfEmpty();
 	}
 
 	@Override
 	public void removeAttr(IAttribute attr) {
 		storage.remove(attr);
+		unloadIfEmpty();
 	}
 
 	@Override
 	public void clearAttributes() {
 		storage.clear();
+		unloadIfEmpty();
+	}
+
+	/**
+	 * Remove all attribute with exceptions from {@link AType#SKIP_ON_UNLOAD}
+	 */
+	public void unloadAttributes() {
+		if (storage == EMPTY_ATTR_STORAGE) {
+			return;
+		}
+		storage.unloadAttributes();
+		unloadIfEmpty();
 	}
 
 	@Override
@@ -96,4 +117,8 @@ public abstract class AttrNode implements IAttributeNode {
 	public String getAttributesString() {
 		return storage.toString();
 	}
+
+	public boolean isAttrStorageEmpty() {
+		return storage.isEmpty();
+	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AttributeStorage.java

@@ -1,9 +1,5 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.dex.attributes.annotations.Annotation;
-import jadx.core.dex.attributes.annotations.AnnotationsList;
-import jadx.core.utils.Utils;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumSet;
@@ -12,6 +8,10 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import jadx.core.dex.attributes.annotations.Annotation;
+import jadx.core.dex.attributes.annotations.AnnotationsList;
+import jadx.core.utils.Utils;
+
 /**
  * Storage for different attribute types:
  * 1. flags - boolean attribute (set or not)
@@ -20,11 +20,11 @@ import java.util.Set;
 public class AttributeStorage {
 
 	private final Set<AFlag> flags;
-	private final Map<AType<?>, IAttribute> attributes;
+	private Map<AType<?>, IAttribute> attributes;
 
 	public AttributeStorage() {
 		flags = EnumSet.noneOf(AFlag.class);
-		attributes = new IdentityHashMap<AType<?>, IAttribute>();
+		attributes = Collections.emptyMap();
 	}
 
 	public void add(AFlag flag) {
@@ -32,13 +32,13 @@ public class AttributeStorage {
 	}
 
 	public void add(IAttribute attr) {
-		attributes.put(attr.getType(), attr);
+		writeAttributes().put(attr.getType(), attr);
 	}
 
 	public <T> void add(AType<AttrList<T>> type, T obj) {
 		AttrList<T> list = get(type);
 		if (list == null) {
-			list = new AttrList<T>(type);
+			list = new AttrList<>(type);
 			add(list);
 		}
 		list.getList().add(obj);
@@ -46,7 +46,7 @@ public class AttributeStorage {
 
 	public void addAll(AttributeStorage otherList) {
 		flags.addAll(otherList.flags);
-		attributes.putAll(otherList.attributes);
+		writeAttributes().putAll(otherList.attributes);
 	}
 
 	public boolean contains(AFlag flag) {
@@ -80,20 +80,41 @@ public class AttributeStorage {
 	}
 
 	public <T extends IAttribute> void remove(AType<T> type) {
-		attributes.remove(type);
-	}
-
-	public void remove(IAttribute attr) {
-		AType<?> type = attr.getType();
-		IAttribute a = attributes.get(type);
-		if (a == attr) {
+		if (!attributes.isEmpty()) {
 			attributes.remove(type);
 		}
 	}
 
+	public void remove(IAttribute attr) {
+		if (!attributes.isEmpty()) {
+			AType<? extends IAttribute> type = attr.getType();
+			IAttribute a = attributes.get(type);
+			if (a == attr) {
+				attributes.remove(type);
+			}
+		}
+	}
+
+	private Map<AType<?>, IAttribute> writeAttributes() {
+		if (attributes.isEmpty()) {
+			attributes = new IdentityHashMap<>(5);
+		}
+		return attributes;
+	}
+
 	public void clear() {
 		flags.clear();
-		attributes.clear();
+		if (!attributes.isEmpty()) {
+			attributes.clear();
+		}
+	}
+
+	public synchronized void unloadAttributes() {
+		if (attributes.isEmpty()) {
+			return;
+		}
+		Set<AType<?>> skipOnUnload = AType.SKIP_ON_UNLOAD;
+		attributes.keySet().removeIf(attrType -> !skipOnUnload.contains(attrType));
 	}
 
 	public List<String> getAttributeStrings() {
@@ -101,7 +122,7 @@ public class AttributeStorage {
 		if (size == 0) {
 			return Collections.emptyList();
 		}
-		List<String> list = new ArrayList<String>(size);
+		List<String> list = new ArrayList<>(size);
 		for (AFlag a : flags) {
 			list.add(a.toString());
 		}
@@ -121,6 +142,7 @@ public class AttributeStorage {
 		if (list.isEmpty()) {
 			return "";
 		}
-		return "A:{" + Utils.listToString(list) + "}";
+		list.sort(String::compareTo);
+		return "A[" + Utils.listToString(list) + ']';
 	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/EmptyAttrStorage.java

@@ -1,10 +1,10 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.dex.attributes.annotations.Annotation;
-
 import java.util.Collections;
 import java.util.List;
 
+import jadx.core.dex.attributes.annotations.Annotation;
+
 public final class EmptyAttrStorage extends AttributeStorage {
 
 	@Override
@@ -34,18 +34,22 @@ public final class EmptyAttrStorage extends AttributeStorage {
 
 	@Override
 	public void clear() {
+		// ignore
 	}
 
 	@Override
 	public void remove(AFlag flag) {
+		// ignore
 	}
 
 	@Override
 	public <T extends IAttribute> void remove(AType<T> type) {
+		// ignore
 	}
 
 	@Override
 	public void remove(IAttribute attr) {
+		// ignore
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/attributes/IAttribute.java

@@ -1,7 +1,5 @@
 package jadx.core.dex.attributes;
 
 public interface IAttribute {
-
-	AType<?> getType();
-
+	AType<? extends IAttribute> getType();
 }

jadx-core/src/main/java/jadx/core/dex/attributes/IAttributeNode.java

@@ -1,9 +1,9 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.dex.attributes.annotations.Annotation;
-
 import java.util.List;
 
+import jadx.core.dex.attributes.annotations.Annotation;
+
 public interface IAttributeNode {
 
 	void add(AFlag flag);

jadx-core/src/main/java/jadx/core/dex/attributes/annotations/Annotation.java

@@ -1,9 +1,9 @@
 package jadx.core.dex.attributes.annotations;
 
-import jadx.core.dex.instructions.args.ArgType;
-
 import java.util.Map;
 
+import jadx.core.dex.instructions.args.ArgType;
+
 public class Annotation {
 
 	public enum Visibility {
@@ -42,7 +42,6 @@ public class Annotation {
 
 	@Override
 	public String toString() {
-		return "Annotation[" + visibility + ", " + atype + ", " + values + "]";
+		return "Annotation[" + visibility + ", " + atype + ", " + values + ']';
 	}
-
 }

jadx-core/src/main/java/jadx/core/dex/attributes/annotations/AnnotationsList.java

@@ -1,23 +1,23 @@
 package jadx.core.dex.attributes.annotations;
 
-import jadx.core.dex.attributes.AType;
-import jadx.core.dex.attributes.IAttribute;
-import jadx.core.utils.Utils;
-
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.IAttribute;
+import jadx.core.utils.Utils;
+
 public class AnnotationsList implements IAttribute {
 
-	public static final AnnotationsList EMPTY = new AnnotationsList(Collections.<Annotation>emptyList());
+	public static final AnnotationsList EMPTY = new AnnotationsList(Collections.emptyList());
 
 	private final Map<String, Annotation> map;
 
 	public AnnotationsList(List<Annotation> anList) {
-		map = new HashMap<String, Annotation>(anList.size());
+		map = new HashMap<>(anList.size());
 		for (Annotation a : anList) {
 			map.put(a.getAnnotationClass(), a);
 		}
@@ -48,5 +48,4 @@ public class AnnotationsList implements IAttribute {
 	public String toString() {
 		return Utils.listToString(map.values());
 	}
-
 }

jadx-core/src/main/java/jadx/core/dex/attributes/annotations/MethodParameters.java

@@ -1,18 +1,18 @@
 package jadx.core.dex.attributes.annotations;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
 import jadx.core.utils.Utils;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class MethodParameters implements IAttribute {
 
 	private final List<AnnotationsList> paramList;
 
 	public MethodParameters(int paramCount) {
-		paramList = new ArrayList<AnnotationsList>(paramCount);
+		paramList = new ArrayList<>(paramCount);
 	}
 
 	public List<AnnotationsList> getParamList() {
@@ -28,5 +28,4 @@ public class MethodParameters implements IAttribute {
 	public String toString() {
 		return Utils.listToString(paramList);
 	}
-
 }

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/DeclareVariablesAttr.java

@@ -1,25 +1,25 @@
 package jadx.core.dex.attributes.nodes;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
-import jadx.core.dex.instructions.args.RegisterArg;
+import jadx.core.dex.instructions.args.CodeVar;
 import jadx.core.utils.Utils;
 
-import java.util.LinkedList;
-import java.util.List;
-
 /**
  * List of variables to be declared at region start.
  */
 public class DeclareVariablesAttr implements IAttribute {
 
-	private final List<RegisterArg> vars = new LinkedList<RegisterArg>();
+	private final List<CodeVar> vars = new ArrayList<>();
 
-	public Iterable<RegisterArg> getVars() {
+	public Iterable<CodeVar> getVars() {
 		return vars;
 	}
 
-	public void addVar(RegisterArg arg) {
+	public void addVar(CodeVar arg) {
 		vars.add(arg);
 	}
 

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/EdgeInsnAttr.java

@@ -1,5 +1,7 @@
 package jadx.core.dex.attributes.nodes;
 
+import java.util.Objects;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.AttrList;
 import jadx.core.dex.attributes.IAttribute;
@@ -14,8 +16,12 @@ public class EdgeInsnAttr implements IAttribute {
 
 	public static void addEdgeInsn(BlockNode start, BlockNode end, InsnNode insn) {
 		EdgeInsnAttr edgeInsnAttr = new EdgeInsnAttr(start, end, insn);
-		start.addAttr(AType.EDGE_INSN, edgeInsnAttr);
-		end.addAttr(AType.EDGE_INSN, edgeInsnAttr);
+		if (!start.getAll(AType.EDGE_INSN).contains(edgeInsnAttr)) {
+			start.addAttr(AType.EDGE_INSN, edgeInsnAttr);
+		}
+		if (!end.getAll(AType.EDGE_INSN).contains(edgeInsnAttr)) {
+			end.addAttr(AType.EDGE_INSN, edgeInsnAttr);
+		}
 	}
 
 	public EdgeInsnAttr(BlockNode start, BlockNode end, InsnNode insn) {
@@ -41,8 +47,27 @@ public class EdgeInsnAttr implements IAttribute {
 		return insn;
 	}
 
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
+		EdgeInsnAttr that = (EdgeInsnAttr) o;
+		return start.equals(that.start)
+				&& end.equals(that.end)
+				&& insn.isDeepEquals(that.insn);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(start, end, insn);
+	}
+
 	@Override
 	public String toString() {
-		return "EDGE_INSN: " + start + "->" + end + " " + insn;
+		return "EDGE_INSN: " + start + "->" + end + ' ' + insn;
 	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/EnumClassAttr.java

@@ -1,5 +1,8 @@
 package jadx.core.dex.attributes.nodes;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
 import jadx.core.dex.info.FieldInfo;
@@ -7,9 +10,6 @@ import jadx.core.dex.instructions.mods.ConstructorInsn;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.MethodNode;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class EnumClassAttr implements IAttribute {
 
 	public static class EnumField {
@@ -54,7 +54,7 @@ public class EnumClassAttr implements IAttribute {
 	private MethodNode staticMethod;
 
 	public EnumClassAttr(int fieldsCount) {
-		this.fields = new ArrayList<EnumField>(fieldsCount);
+		this.fields = new ArrayList<>(fieldsCount);
 	}
 
 	public List<EnumField> getFields() {
@@ -78,5 +78,4 @@ public class EnumClassAttr implements IAttribute {
 	public String toString() {
 		return "Enum fields: " + fields;
 	}
-
 }