fix: remap class names for store in disk cache (#1503)

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 1 to 2.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/v1...v2)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  # Set update schedule for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/build-artifacts.yml

@@ -0,0 +1,86 @@
+name: Build Artifacts
+
+on:
+  push:
+    branches: [ master, build-test ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'adopt'
+          java-version: 8
+
+      - name: Set jadx version
+        run: |
+          JADX_LAST_TAG=$(git describe --abbrev=0 --tags)
+          JADX_VERSION="${JADX_LAST_TAG:1}.$GITHUB_RUN_NUMBER-${GITHUB_SHA:0:8}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - uses: burrunan/gradle-cache-action@v1
+        name: Build with Gradle
+        env:
+          TERM: dumb
+        with:
+          arguments: clean dist copyExe
+
+      - name: Save bundle artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ format('jadx-{0}', env.JADX_VERSION) }}
+          # Waiting fix for https://github.com/actions/upload-artifact/issues/39 to upload zip file
+          # Upload unpacked files for now
+          path: build/jadx/**/*
+          if-no-files-found: error
+          retention-days: 30
+
+      - name: Save exe artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ format('jadx-gui-{0}-no-jre-win.exe', env.JADX_VERSION) }}
+          path: build/*.exe
+          if-no-files-found: error
+          retention-days: 30
+
+  build-win-bundle:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: oracle-actions/setup-java@v1 # set latest java version by default
+
+      - name: Print Java version
+        shell: bash
+        run: java -version
+
+      - name: Set jadx version
+        shell: bash
+        run: |
+          JADX_LAST_TAG=$(git describe --abbrev=0 --tags)
+          JADX_VERSION="${JADX_LAST_TAG:1}.$GITHUB_RUN_NUMBER-${GITHUB_SHA:0:8}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - uses: gradle/gradle-build-action@v2
+        name: Build with Gradle
+        env:
+          TERM: dumb
+        with:
+          arguments: clean dist -PbundleJRE=true
+
+      - name: Save exe bundle artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ format('jadx-gui-{0}-with-jre-win', env.JADX_VERSION) }}
+          path: jadx-gui/build/*-with-jre-win/*
+          if-no-files-found: error
+          retention-days: 30

.github/workflows/build-test.yml

@@ -0,0 +1,28 @@
+name: Build Test
+
+on:
+  push:
+    branches: [ master, build-test ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'adopt'
+          java-version: 8
+
+      - uses: burrunan/gradle-cache-action@v1
+        name: Build with Gradle
+        env:
+          TERM: dumb
+        with:
+          arguments: clean build dist copyExe --warning-mode=all

.github/workflows/build.yml

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

.github/workflows/codeql-analysis.yml

@@ -28,7 +28,7 @@ jobs:
       uses: actions/checkout@v2
 
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
+      uses: github/codeql-action/init@v2
       with:
         queries: +security-extended
         languages: ${{ matrix.language }}
@@ -38,4 +38,4 @@ jobs:
         ./gradlew clean build -x checkstyleTest -x checkstyleMain -x test -x ':jadx-core:testClasses'
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1
+      uses: github/codeql-action/analyze@v2

.gitignore

@@ -35,4 +35,5 @@ jadx-output/
 *.orig
 quark.json
 
-cliff.toml
+cliff.toml
+jadx-gui/src/main/resources/logback.xml

README.md

@@ -33,8 +33,9 @@ See these features in action here: [jadx-gui features overview](https://github.c
 <img src="https://user-images.githubusercontent.com/118523/142730720-839f017e-38db-423e-b53f-39f5f0a0316f.png" width="700"/>
 
 ### Download
-- release from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
+- release
-- latest [unstable build](https://nightly.link/skylot/jadx/workflows/build/master)
+  from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
+- latest [unstable build](https://nightly.link/skylot/jadx/workflows/build-artifacts/master)
 
 After download unpack zip file go to `bin` directory and run:
 - `jadx` - command line version

appdata.xml

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<component type="desktop">
-    <id>com.github.skylot.jadx</id>
-    <metadata_license>CC0-1.0</metadata_license>
-    <project_license>Apache-2.0</project_license>
-    <name>JADX</name>
-    <summary>Dex to Java decompiler</summary>
-    <description>
-        <p>Command line and GUI tools for producing Java source code from Android Dex and Apk files</p>
-        <ul>
-            <li>decompile Dalvik bytecode to java classes from APK, dex, aar, aab and zip files</li>
-            <li>decode AndroidManifest.xml and other resources from resources.arsc</li>
-            <li>deobfuscator included</li>
-            <li>view decompiled code with highlighted syntax</li>
-            <li>jump to declaration</li>
-            <li>find usage</li>
-            <li>full text search</li>
-            <li>smali debugger</li>
-        </ul>
-    </description>
-    <screenshots>
-        <screenshot type="default">
-            <image>https://user-images.githubusercontent.com/118523/142730720-839f017e-38db-423e-b53f-39f5f0a0316f.png</image>
-        </screenshot>
-    </screenshots>
-    <content_rating type="oars-1.1" />
-    <launchable type="desktop-id">com.github.skylot.jadx.desktop</launchable>
-    <url type="homepage">https://github.com/skylot/jadx</url>
-    <url type="bugtracker">https://github.com/skylot/jadx/issues</url>
-    <releases>
-        <release version="1.3.4" date="2022-03-20" />
-    </releases>
-</component>

build.gradle

@@ -1,6 +1,6 @@
 plugins {
 	id 'com.github.ben-manes.versions' version '0.42.0'
-	id 'com.diffplug.spotless' version '6.4.2'
+	id 'com.diffplug.spotless' version '6.6.1'
 }
 
 ext.jadxVersion = System.getenv('JADX_VERSION') ?: "dev"
@@ -14,7 +14,6 @@ allprojects {
 	version = jadxVersion
 
 	sourceCompatibility = JavaVersion.VERSION_1_8
-	targetCompatibility = JavaVersion.VERSION_1_8
 
 	compileJava {
 		options.encoding = "UTF-8"
@@ -32,7 +31,7 @@ allprojects {
 
 		testImplementation 'ch.qos.logback:logback-classic:1.2.11'
 		testImplementation 'org.hamcrest:hamcrest-library:2.2'
-		testImplementation 'org.mockito:mockito-core:4.4.0'
+		testImplementation 'org.mockito:mockito-core:4.6.0'
 		testImplementation 'org.assertj:assertj-core:3.22.0'
 
 		testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
@@ -64,13 +63,7 @@ spotless {
 
 		importOrderFile 'config/code-formatter/eclipse.importorder'
 		eclipse().configFile 'config/code-formatter/eclipse.xml'
-		if (JavaVersion.current() < JavaVersion.VERSION_16) {
+		removeUnusedImports()
-			removeUnusedImports()
-		} else {
-			// google-format on Java 16+ issue: https://github.com/diffplug/spotless/issues/834
-			println('Warning! Unused imports remove is disabled for Java 16+'
-					+ ' (use workaround from https://github.com/diffplug/spotless/tree/main/plugin-gradle#google-java-format)')
-		}
 
 		lineEndings(com.diffplug.spotless.LineEnding.UNIX)
 		encoding("UTF-8")

gradle.properties

@@ -1,2 +1,11 @@
 org.gradle.warning.mode=all
 org.gradle.parallel=true
+
+# Flags for google-java-format (optimize imports by spotless) for Java >= 16.
+# Java < 9 will ignore unsupported flags (thanks to -XX:+IgnoreUnrecognizedVMOptions)
+org.gradle.jvmargs=-XX:+IgnoreUnrecognizedVMOptions \
+  --add-exports='jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED'

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

@@ -8,6 +8,7 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.function.Supplier;
 
 import org.jetbrains.annotations.Nullable;
 
@@ -22,6 +23,7 @@ import jadx.api.plugins.JadxPluginInfo;
 import jadx.api.plugins.JadxPluginManager;
 import jadx.api.plugins.options.JadxPluginOptions;
 import jadx.api.plugins.options.OptionDescription;
+import jadx.core.utils.Utils;
 
 public class JCommanderWrapper<T> {
 	private final JCommander jc;
@@ -50,12 +52,24 @@ public class JCommanderWrapper<T> {
 			if (parameter.isAssigned()) {
 				// copy assigned field value to obj
 				Parameterized parameterized = parameter.getParameterized();
-				Object val = parameterized.get(parameter.getObject());
+				Object providedValue = parameterized.get(parameter.getObject());
-				parameterized.set(obj, val);
+				Object newValue = mergeValues(parameterized.getType(), providedValue, () -> parameterized.get(obj));
+				parameterized.set(obj, newValue);
 			}
 		}
 	}
 
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	private static Object mergeValues(Class<?> type, Object value, Supplier<Object> prevValueProvider) {
+		if (type.isAssignableFrom(Map.class)) {
+			// merge maps instead replacing whole map
+			Map prevMap = (Map) prevValueProvider.get();
+			return Utils.mergeMaps(prevMap, (Map) value); // value map will override keys in prevMap
+		}
+		// simple override
+		return value;
+	}
+
 	public void printUsage() {
 		// print usage in not sorted fields order (by default its sorted by description)
 		PrintStream out = System.out;

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

@@ -21,7 +21,7 @@ public class JadxCLI {
 		} catch (JadxArgsValidateException e) {
 			LOG.error("Incorrect arguments: {}", e.getMessage());
 			result = 1;
-		} catch (Exception e) {
+		} catch (Throwable e) {
 			LOG.error("Process error:", e);
 			result = 1;
 		} finally {

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

@@ -1,9 +1,14 @@
 package jadx.cli;
 
+import java.util.Collections;
+import java.util.Map;
+
+import org.hamcrest.Matchers;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import static jadx.core.utils.Utils.newConstStringMap;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
 
@@ -47,6 +52,40 @@ public class JadxCLIArgsTest {
 		assertThat(override(args, "").isUseImports(), is(false));
 	}
 
+	@Test
+	public void testPluginOptionsOverride() {
+		// add key to empty base map
+		checkPluginOptionsMerge(
+				Collections.emptyMap(),
+				"-Poption=otherValue",
+				newConstStringMap("option", "otherValue"));
+
+		// override one key
+		checkPluginOptionsMerge(
+				newConstStringMap("option", "value"),
+				"-Poption=otherValue",
+				newConstStringMap("option", "otherValue"));
+
+		// merge different keys
+		checkPluginOptionsMerge(
+				Collections.singletonMap("option1", "value1"),
+				"-Poption2=otherValue2",
+				newConstStringMap("option1", "value1", "option2", "otherValue2"));
+
+		// merge and override
+		checkPluginOptionsMerge(
+				newConstStringMap("option1", "value1", "option2", "value2"),
+				"-Poption2=otherValue2",
+				newConstStringMap("option1", "value1", "option2", "otherValue2"));
+	}
+
+	private void checkPluginOptionsMerge(Map<String, String> baseMap, String providedArgs, Map<String, String> expectedMap) {
+		JadxCLIArgs args = new JadxCLIArgs();
+		args.pluginOptions = baseMap;
+		Map<String, String> resultMap = override(args, providedArgs).getPluginOptions();
+		assertThat(resultMap, Matchers.equalTo(expectedMap));
+	}
+
 	private JadxCLIArgs parse(String... args) {
 		return parse(new JadxCLIArgs(), args);
 	}

jadx-core/build.gradle

@@ -14,7 +14,7 @@ dependencies {
 
 	testImplementation 'org.apache.commons:commons-lang3:3.12.0'
 
-	testRuntimeOnly(project(':jadx-plugins:jadx-dex-input'))
+	testImplementation(project(':jadx-plugins:jadx-dex-input'))
 	testRuntimeOnly(project(':jadx-plugins:jadx-smali-input'))
 	testRuntimeOnly(project(':jadx-plugins:jadx-java-convert'))
 	testRuntimeOnly(project(':jadx-plugins:jadx-java-input'))

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

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

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

@@ -1,13 +1,21 @@
 package jadx.api;
 
+import java.io.Closeable;
+
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public interface ICodeCache {
+public interface ICodeCache extends Closeable {
 
 	void add(String clsFullName, ICodeInfo codeInfo);
 
 	void remove(String clsFullName);
 
-	@Nullable
+	@NotNull
 	ICodeInfo get(String clsFullName);
+
+	@Nullable
+	String getCode(String clsFullName);
+
+	boolean contains(String clsFullName);
 }

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

@@ -1,8 +1,7 @@
 package jadx.api;
 
-import java.util.Map;
-
 import jadx.api.impl.SimpleCodeInfo;
+import jadx.api.metadata.ICodeMetadata;
 
 public interface ICodeInfo {
 
@@ -10,7 +9,7 @@ public interface ICodeInfo {
 
 	String getCodeStr();
 
-	Map<Integer, Integer> getLineMapping();
+	ICodeMetadata getCodeMetadata();
 
-	Map<CodePosition, Object> getAnnotations();
+	boolean hasMetadata();
 }

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

@@ -2,7 +2,10 @@ package jadx.api;
 
 import java.util.Map;
 
-import jadx.core.dex.attributes.ILineAttributeNode;
+import org.jetbrains.annotations.ApiStatus;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
 
 public interface ICodeWriter {
 	String NL = System.getProperty("line.separator");
@@ -38,13 +41,21 @@ public interface ICodeWriter {
 
 	void setIndent(int indent);
 
+	/**
+	 * Return current line (only if metadata is supported)
+	 */
 	int getLine();
 
-	void attachDefinition(ILineAttributeNode obj);
+	/**
+	 * Return start line position (only if metadata is supported)
+	 */
+	int getLineStartPos();
 
-	void attachAnnotation(Object obj);
+	void attachDefinition(ICodeNodeRef obj);
 
-	void attachLineAnnotation(Object obj);
+	void attachAnnotation(ICodeAnnotation obj);
+
+	void attachLineAnnotation(ICodeAnnotation obj);
 
 	void attachSourceLine(int sourceLine);
 
@@ -56,5 +67,6 @@ public interface ICodeWriter {
 
 	StringBuilder getRawBuf();
 
-	Map<CodePosition, Object> getRawAnnotations();
+	@ApiStatus.Internal
+	Map<Integer, ICodeAnnotation> getRawAnnotations();
 }

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

@@ -1,6 +1,7 @@
 package jadx.api;
 
 import java.io.File;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumSet;
@@ -11,12 +12,17 @@ import java.util.Set;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import jadx.api.args.DeobfuscationMapFileMode;
 import jadx.api.data.ICodeData;
 import jadx.api.impl.AnnotatedCodeWriter;
 import jadx.api.impl.InMemoryCodeCache;
+import jadx.core.utils.files.FileUtils;
 
 public class JadxArgs {
+	private static final Logger LOG = LoggerFactory.getLogger(JadxArgs.class);
 
 	public static final int DEFAULT_THREADS_COUNT = Math.max(1, Runtime.getRuntime().availableProcessors() / 2);
 
@@ -55,6 +61,11 @@ public class JadxArgs {
 	 */
 	private Predicate<String> classFilter = null;
 
+	/**
+	 * Save dependencies for classes accepted by {@code classFilter}
+	 */
+	private boolean includeDependencies = false;
+
 	private boolean deobfuscationOn = false;
 	private boolean useSourceNameAsClassAlias = false;
 	private boolean parseKotlinMetadata = false;
@@ -115,6 +126,19 @@ public class JadxArgs {
 		setOutDirRes(new File(rootDir, DEFAULT_RES_DIR));
 	}
 
+	public void close() {
+		try {
+			inputFiles.clear();
+			if (codeCache != null) {
+				codeCache.close();
+			}
+		} catch (Exception e) {
+			LOG.error("Failed to close JadxArgs", e);
+		} finally {
+			codeCache = null;
+		}
+	}
+
 	public List<File> getInputFiles() {
 		return inputFiles;
 	}
@@ -261,6 +285,14 @@ public class JadxArgs {
 		this.skipSources = skipSources;
 	}
 
+	public void setIncludeDependencies(boolean includeDependencies) {
+		this.includeDependencies = includeDependencies;
+	}
+
+	public boolean isIncludeDependencies() {
+		return includeDependencies;
+	}
+
 	public Predicate<String> getClassFilter() {
 		return classFilter;
 	}
@@ -501,6 +533,21 @@ public class JadxArgs {
 		this.pluginOptions = pluginOptions;
 	}
 
+	/**
+	 * Hash of all options that can change result code
+	 */
+	public String makeCodeArgsHash() {
+		String argStr = "args:" + decompilationMode + useImports + showInconsistentCode
+				+ inlineAnonymousClasses + inlineMethods
+				+ deobfuscationOn + deobfuscationMinLength + deobfuscationMaxLength
+				+ parseKotlinMetadata + useKotlinMethodsForVarNames
+				+ insertDebugLines + extractFinally
+				+ debugInfo + useSourceNameAsClassAlias + escapeUnicode + replaceConsts
+				+ respectBytecodeAccModifiers + fsCaseSensitive + renameFlags
+				+ commentsLevel + useDxInput + pluginOptions;
+		return FileUtils.md5Sum(argStr.getBytes(StandardCharsets.US_ASCII));
+	}
+
 	@Override
 	public String toString() {
 		return "JadxArgs{" + "inputFiles=" + inputFiles
@@ -513,12 +560,15 @@ public class JadxArgs {
 				+ ", useImports=" + useImports
 				+ ", skipResources=" + skipResources
 				+ ", skipSources=" + skipSources
+				+ ", includeDependencies=" + includeDependencies
 				+ ", deobfuscationOn=" + deobfuscationOn
 				+ ", deobfuscationMapFile=" + deobfuscationMapFile
 				+ ", deobfuscationMapFileMode=" + deobfuscationMapFileMode
 				+ ", useSourceNameAsClassAlias=" + useSourceNameAsClassAlias
 				+ ", parseKotlinMetadata=" + parseKotlinMetadata
 				+ ", useKotlinMethodsForVarNames=" + useKotlinMethodsForVarNames
+				+ ", insertDebugLines=" + insertDebugLines
+				+ ", extractFinally=" + extractFinally
 				+ ", deobfuscationMinLength=" + deobfuscationMinLength
 				+ ", deobfuscationMaxLength=" + deobfuscationMaxLength
 				+ ", escapeUnicode=" + escapeUnicode

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

@@ -13,8 +13,9 @@ public class JadxArgsValidator {
 
 	private static final Logger LOG = LoggerFactory.getLogger(JadxArgsValidator.class);
 
-	public static void validate(JadxArgs args) {
+	public static void validate(JadxDecompiler jadx) {
-		checkInputFiles(args);
+		JadxArgs args = jadx.getArgs();
+		checkInputFiles(jadx, args);
 		validateOutDirs(args);
 
 		if (LOG.isDebugEnabled()) {
@@ -22,9 +23,9 @@ public class JadxArgsValidator {
 		}
 	}
 
-	private static void checkInputFiles(JadxArgs args) {
+	private static void checkInputFiles(JadxDecompiler jadx, JadxArgs args) {
 		List<File> inputFiles = args.getInputFiles();
-		if (inputFiles.isEmpty()) {
+		if (inputFiles.isEmpty() && jadx.getCustomLoads().isEmpty()) {
 			throw new JadxArgsValidateException("Please specify input file");
 		}
 		for (File inputFile : inputFiles) {
@@ -66,19 +67,22 @@ public class JadxArgsValidator {
 
 	@NotNull
 	private static File makeDirFromInput(JadxArgs args) {
-		File outDir;
 		String outDirName;
-		File file = args.getInputFiles().get(0);
+		List<File> inputFiles = args.getInputFiles();
-		String name = file.getName();
+		if (inputFiles.isEmpty()) {
-		int pos = name.lastIndexOf('.');
+			outDirName = JadxArgs.DEFAULT_OUT_DIR;
-		if (pos != -1) {
-			outDirName = name.substring(0, pos);
 		} else {
-			outDirName = name + '-' + JadxArgs.DEFAULT_OUT_DIR;
+			File file = inputFiles.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 new File(outDirName);
-		return outDir;
 	}
 
 	private static void checkFile(File file) {

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

@@ -25,7 +25,11 @@ import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import jadx.api.data.annotations.VarRef;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.api.metadata.annotations.NodeDeclareRef;
+import jadx.api.metadata.annotations.VarNode;
+import jadx.api.metadata.annotations.VarRef;
 import jadx.api.plugins.JadxPlugin;
 import jadx.api.plugins.JadxPluginManager;
 import jadx.api.plugins.input.JadxInputPlugin;
@@ -35,7 +39,6 @@ import jadx.core.Jadx;
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.InlinedAttr;
-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;
@@ -96,7 +99,9 @@ public final class JadxDecompiler implements Closeable {
 	private final Map<MethodNode, JavaMethod> methodsMap = new ConcurrentHashMap<>();
 	private final Map<FieldNode, JavaField> fieldsMap = new ConcurrentHashMap<>();
 
-	private final IDecompileScheduler decompileScheduler = new DecompilerScheduler(this);
+	private final IDecompileScheduler decompileScheduler = new DecompilerScheduler();
+
+	private final List<ILoadResult> customLoads = new ArrayList<>();
 
 	public JadxDecompiler() {
 		this(new JadxArgs());
@@ -108,7 +113,7 @@ public final class JadxDecompiler implements Closeable {
 
 	public void load() {
 		reset();
-		JadxArgsValidator.validate(args);
+		JadxArgsValidator.validate(this);
 		LOG.info("loading ...");
 		loadPlugins(args);
 		loadInputFiles();
@@ -132,11 +137,20 @@ public final class JadxDecompiler implements Closeable {
 				loadedInputs.add(loadResult);
 			}
 		}
+		loadedInputs.addAll(customLoads);
 		if (LOG.isDebugEnabled()) {
 			LOG.debug("Loaded using {} inputs plugin in {} ms", loadedInputs.size(), System.currentTimeMillis() - start);
 		}
 	}
 
+	public void addCustomLoad(ILoadResult customLoad) {
+		customLoads.add(customLoad);
+	}
+
+	public List<ILoadResult> getCustomLoads() {
+		return customLoads;
+	}
+
 	private void reset() {
 		root = null;
 		classes = null;
@@ -147,8 +161,13 @@ public final class JadxDecompiler implements Closeable {
 		classesMap.clear();
 		methodsMap.clear();
 		fieldsMap.clear();
+	}
 
+	@Override
+	public void close() {
+		reset();
 		closeInputs();
+		args.close();
 	}
 
 	private void closeInputs() {
@@ -162,11 +181,6 @@ public final class JadxDecompiler implements Closeable {
 		loadedInputs.clear();
 	}
 
-	@Override
-	public void close() {
-		reset();
-	}
-
 	private void loadPlugins(JadxArgs args) {
 		pluginManager.providesSuggestion("java-input", args.isUseDxInput() ? "java-convert" : "java-input");
 		pluginManager.load();
@@ -188,6 +202,7 @@ public final class JadxDecompiler implements Closeable {
 		}
 	}
 
+	@SuppressWarnings("unused")
 	public void registerPlugin(JadxPlugin plugin) {
 		pluginManager.register(plugin);
 	}
@@ -229,6 +244,7 @@ public final class JadxDecompiler implements Closeable {
 		save(false, true);
 	}
 
+	@SuppressWarnings("ResultOfMethodCallIgnored")
 	private void save(boolean saveSources, boolean saveResources) {
 		ExecutorService ex = getSaveExecutor(saveSources, saveResources);
 		ex.shutdown();
@@ -320,10 +336,14 @@ public final class JadxDecompiler implements Closeable {
 		List<JavaClass> classes = getClasses();
 		List<JavaClass> processQueue = new ArrayList<>(classes.size());
 		for (JavaClass cls : classes) {
-			if (cls.getClassNode().contains(AFlag.DONT_GENERATE)) {
+			ClassNode clsNode = cls.getClassNode();
+			if (clsNode.contains(AFlag.DONT_GENERATE)) {
 				continue;
 			}
-			if (classFilter != null && !classFilter.test(cls.getFullName())) {
+			if (classFilter != null && !classFilter.test(clsNode.getClassInfo().getFullName())) {
+				if (!args.isIncludeDependencies()) {
+					clsNode.add(AFlag.DONT_GENERATE);
+				}
 				continue;
 			}
 			processQueue.add(cls);
@@ -353,14 +373,14 @@ public final class JadxDecompiler implements Closeable {
 			return Collections.emptyList();
 		}
 		if (classes == null) {
-			List<ClassNode> classNodeList = root.getClasses(false);
+			List<ClassNode> classNodeList = root.getClasses();
 			List<JavaClass> clsList = new ArrayList<>(classNodeList.size());
-			classesMap.clear();
 			for (ClassNode classNode : classNodeList) {
-				if (!classNode.contains(AFlag.DONT_GENERATE)) {
+				if (classNode.contains(AFlag.DONT_GENERATE)) {
-					JavaClass javaClass = new JavaClass(classNode, this);
+					continue;
-					clsList.add(javaClass);
+				}
-					classesMap.put(classNode, javaClass);
+				if (!classNode.getClassInfo().isInner()) {
+					clsList.add(convertClassNode(classNode));
 				}
 			}
 			classes = Collections.unmodifiableList(clsList);
@@ -368,6 +388,10 @@ public final class JadxDecompiler implements Closeable {
 		return classes;
 	}
 
+	public List<JavaClass> getClassesWithInners() {
+		return Utils.collectionMap(root.getClasses(), this::convertClassNode);
+	}
+
 	public List<ResourceFile> getResources() {
 		if (resources == null) {
 			if (root == null) {
@@ -425,6 +449,7 @@ public final class JadxDecompiler implements Closeable {
 	/**
 	 * Internal API. Not Stable!
 	 */
+	@ApiStatus.Internal
 	public RootNode getRoot() {
 		return root;
 	}
@@ -443,23 +468,10 @@ public final class JadxDecompiler implements Closeable {
 		return protoXmlParser;
 	}
 
-	private void loadJavaClass(JavaClass javaClass) {
-		javaClass.getMethods().forEach(mth -> methodsMap.put(mth.getMethodNode(), mth));
-		javaClass.getFields().forEach(fld -> fieldsMap.put(fld.getFieldNode(), fld));
-
-		for (JavaClass innerCls : javaClass.getInnerClasses()) {
-			classesMap.put(innerCls.getClassNode(), innerCls);
-			loadJavaClass(innerCls);
-		}
-		for (JavaClass inlinedCls : javaClass.getInlinedClasses()) {
-			classesMap.put(inlinedCls.getClassNode(), inlinedCls);
-			loadJavaClass(inlinedCls);
-		}
-	}
-
 	/**
 	 * Get JavaClass by ClassNode without loading and decompilation
 	 */
+	@ApiStatus.Internal
 	JavaClass convertClassNode(ClassNode cls) {
 		return classesMap.compute(cls, (node, prevJavaCls) -> {
 			if (prevJavaCls != null && prevJavaCls.getClassNode() == cls) {
@@ -473,65 +485,23 @@ public final class JadxDecompiler implements Closeable {
 		});
 	}
 
-	@Nullable("For not generated classes")
 	@ApiStatus.Internal
-	public JavaClass getJavaClassByNode(ClassNode cls) {
+	JavaField convertFieldNode(FieldNode field) {
-		JavaClass javaClass = classesMap.get(cls);
+		return fieldsMap.computeIfAbsent(field, fldNode -> {
-		if (javaClass != null && javaClass.getClassNode() == cls) {
+			JavaClass parentCls = convertClassNode(fldNode.getParentClass());
-			return javaClass;
+			return new JavaField(parentCls, fldNode);
-		}
+		});
-		// load parent class if inner
-		ClassNode parentClass = cls.getTopParentClass();
-		if (parentClass.contains(AFlag.DONT_GENERATE)) {
-			return null;
-		}
-		JavaClass parentJavaClass = classesMap.get(parentClass);
-		if (parentJavaClass == null) {
-			getClasses();
-			parentJavaClass = classesMap.get(parentClass);
-		}
-		if (parentJavaClass != null) {
-			loadJavaClass(parentJavaClass);
-			javaClass = classesMap.get(cls);
-			if (javaClass != null) {
-				return javaClass;
-			}
-		}
-		// class or parent classes can be excluded from generation
-		if (cls.hasNotGeneratedParent()) {
-			return null;
-		}
-		throw new JadxRuntimeException("JavaClass not found by ClassNode: " + cls);
 	}
 
-	@Nullable
+	@ApiStatus.Internal
-	private JavaMethod getJavaMethodByNode(MethodNode mth) {
+	JavaMethod convertMethodNode(MethodNode method) {
-		JavaMethod javaMethod = methodsMap.get(mth);
+		return methodsMap.computeIfAbsent(method, mthNode -> {
-		if (javaMethod != null && javaMethod.getMethodNode() == mth) {
+			ClassNode codeCls = getCodeParentClass(mthNode.getParentClass());
-			return javaMethod;
+			return new JavaMethod(convertClassNode(codeCls), mthNode);
-		}
+		});
-		if (mth.contains(AFlag.DONT_GENERATE)) {
-			return null;
-		}
-		// parent class not loaded yet
-		ClassNode parentClass = mth.getParentClass();
-		ClassNode codeCls = getCodeParentClass(parentClass);
-		JavaClass javaClass = getJavaClassByNode(codeCls);
-		if (javaClass == null) {
-			return null;
-		}
-		loadJavaClass(javaClass);
-		javaMethod = methodsMap.get(mth);
-		if (javaMethod != null) {
-			return javaMethod;
-		}
-		if (parentClass.hasNotGeneratedParent()) {
-			return null;
-		}
-		throw new JadxRuntimeException("JavaMethod not found by MethodNode: " + mth);
 	}
 
-	private ClassNode getCodeParentClass(ClassNode cls) {
+	private static ClassNode getCodeParentClass(ClassNode cls) {
 		ClassNode codeCls;
 		InlinedAttr inlinedAttr = cls.get(AType.INLINED);
 		if (inlinedAttr != null) {
@@ -545,34 +515,12 @@ public final class JadxDecompiler implements Closeable {
 		return getCodeParentClass(codeCls);
 	}
 
-	@Nullable
-	private JavaField getJavaFieldByNode(FieldNode fld) {
-		JavaField javaField = fieldsMap.get(fld);
-		if (javaField != null && javaField.getFieldNode() == fld) {
-			return javaField;
-		}
-		// parent class not loaded yet
-		JavaClass javaClass = getJavaClassByNode(fld.getParentClass().getTopParentClass());
-		if (javaClass == null) {
-			return null;
-		}
-		loadJavaClass(javaClass);
-		javaField = fieldsMap.get(fld);
-		if (javaField != null) {
-			return javaField;
-		}
-		if (fld.getParentClass().hasNotGeneratedParent()) {
-			return null;
-		}
-		throw new JadxRuntimeException("JavaField not found by FieldNode: " + fld);
-	}
-
 	@Nullable
 	public JavaClass searchJavaClassByOrigFullName(String fullName) {
 		return getRoot().getClasses().stream()
 				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
 				.findFirst()
-				.map(this::getJavaClassByNode)
+				.map(this::convertClassNode)
 				.orElse(null);
 	}
 
@@ -593,9 +541,9 @@ public final class JadxDecompiler implements Closeable {
 				.orElse(null);
 		if (node != null) {
 			if (node.contains(AFlag.DONT_GENERATE)) {
-				return getJavaClassByNode(node.getTopParentClass());
+				return convertClassNode(node.getTopParentClass());
 			} else {
-				return getJavaClassByNode(node);
+				return convertClassNode(node);
 			}
 		}
 		return null;
@@ -606,86 +554,92 @@ public final class JadxDecompiler implements Closeable {
 		return getRoot().getClasses().stream()
 				.filter(cls -> cls.getClassInfo().getAliasFullName().equals(fullName))
 				.findFirst()
-				.map(this::getJavaClassByNode)
+				.map(this::convertClassNode)
 				.orElse(null);
 	}
 
 	@Nullable
-	JavaNode convertNode(Object obj) {
+	public JavaNode getJavaNodeByRef(ICodeNodeRef ann) {
-		if (obj instanceof VarRef) {
+		return getJavaNodeByCodeAnnotation(null, ann);
-			VarRef varRef = (VarRef) obj;
+	}
-			MethodNode mthNode = varRef.getMth();
+
-			JavaMethod mth = getJavaMethodByNode(mthNode);
+	@Nullable
-			if (mth == null) {
+	public JavaNode getJavaNodeByCodeAnnotation(@Nullable ICodeInfo codeInfo, @Nullable ICodeAnnotation ann) {
+		if (ann == null) {
+			return null;
+		}
+		switch (ann.getAnnType()) {
+			case CLASS:
+				return convertClassNode((ClassNode) ann);
+			case METHOD:
+				return convertMethodNode((MethodNode) ann);
+			case FIELD:
+				return convertFieldNode((FieldNode) ann);
+			case DECLARATION:
+				return getJavaNodeByCodeAnnotation(codeInfo, ((NodeDeclareRef) ann).getNode());
+			case VAR:
+				return resolveVarNode((VarNode) ann);
+			case VAR_REF:
+				return resolveVarRef(codeInfo, (VarRef) ann);
+			case OFFSET:
+				// offset annotation don't have java node object
 				return null;
+			default:
+				throw new JadxRuntimeException("Unknown annotation type: " + ann.getAnnType() + ", class: " + ann.getClass());
+		}
+	}
+
+	@Nullable
+	private JavaVariable resolveVarNode(VarNode varNode) {
+		MethodNode mthNode = varNode.getMth();
+		JavaMethod mth = convertMethodNode(mthNode);
+		if (mth == null) {
+			return null;
+		}
+		return new JavaVariable(mth, varNode);
+	}
+
+	@Nullable
+	private JavaVariable resolveVarRef(ICodeInfo codeInfo, VarRef varRef) {
+		if (codeInfo == null) {
+			throw new JadxRuntimeException("Missing code info for resolve VarRef: " + varRef);
+		}
+		ICodeAnnotation varNodeAnn = codeInfo.getCodeMetadata().getAt(varRef.getRefPos());
+		if (varNodeAnn != null && varNodeAnn.getAnnType() == ICodeAnnotation.AnnType.DECLARATION) {
+			ICodeNodeRef nodeRef = ((NodeDeclareRef) varNodeAnn).getNode();
+			if (nodeRef.getAnnType() == ICodeAnnotation.AnnType.VAR) {
+				return resolveVarNode((VarNode) nodeRef);
 			}
-			return new JavaVariable(mth, varRef);
 		}
-		if (!(obj instanceof LineAttrNode)) {
+		return null;
-			return null;
-		}
-		LineAttrNode node = (LineAttrNode) obj;
-		if (node.contains(AFlag.DONT_GENERATE)) {
-			return null;
-		}
-		if (obj instanceof ClassNode) {
-			return convertClassNode((ClassNode) obj);
-		}
-		if (obj instanceof MethodNode) {
-			return getJavaMethodByNode(((MethodNode) obj));
-		}
-		if (obj instanceof FieldNode) {
-			return getJavaFieldByNode((FieldNode) obj);
-		}
-		throw new JadxRuntimeException("Unexpected node type: " + obj);
 	}
 
-	// TODO: make interface for all nodes in code annotations and add common method instead this
+	List<JavaNode> convertNodes(Collection<? extends ICodeNodeRef> nodesList) {
-	Object getInternalNode(JavaNode javaNode) {
-		if (javaNode instanceof JavaClass) {
-			return ((JavaClass) javaNode).getClassNode();
-		}
-		if (javaNode instanceof JavaMethod) {
-			return ((JavaMethod) javaNode).getMethodNode();
-		}
-		if (javaNode instanceof JavaField) {
-			return ((JavaField) javaNode).getFieldNode();
-		}
-		if (javaNode instanceof JavaVariable) {
-			return ((JavaVariable) javaNode).getVarRef();
-		}
-		throw new JadxRuntimeException("Unexpected node type: " + javaNode);
-	}
-
-	List<JavaNode> convertNodes(Collection<?> nodesList) {
 		return nodesList.stream()
-				.map(this::convertNode)
+				.map(this::getJavaNodeByRef)
 				.filter(Objects::nonNull)
 				.collect(Collectors.toList());
 	}
 
 	@Nullable
-	public JavaNode getJavaNodeAtPosition(ICodeInfo codeInfo, int line, int offset) {
+	public JavaNode getJavaNodeAtPosition(ICodeInfo codeInfo, int pos) {
-		Map<CodePosition, Object> map = codeInfo.getAnnotations();
+		ICodeAnnotation ann = codeInfo.getCodeMetadata().getAt(pos);
-		if (map.isEmpty()) {
+		return getJavaNodeByCodeAnnotation(codeInfo, ann);
-			return null;
-		}
-		Object obj = map.get(new CodePosition(line, offset));
-		if (obj == null) {
-			return null;
-		}
-		return convertNode(obj);
 	}
 
 	@Nullable
-	public CodePosition getDefinitionPosition(JavaNode javaNode) {
+	public JavaNode getClosestJavaNode(ICodeInfo codeInfo, int pos) {
-		JavaClass jCls = javaNode.getTopParentClass();
+		ICodeAnnotation ann = codeInfo.getCodeMetadata().getClosestUp(pos);
-		jCls.decompile();
+		return getJavaNodeByCodeAnnotation(codeInfo, ann);
-		int defLine = javaNode.getDecompiledLine();
+	}
-		if (defLine == 0) {
+
+	@Nullable
+	public JavaNode getEnclosingNode(ICodeInfo codeInfo, int pos) {
+		ICodeNodeRef obj = codeInfo.getCodeMetadata().getNodeAt(pos);
+		if (obj == null) {
 			return null;
 		}
-		return new CodePosition(defLine, 0, javaNode.getDefPos());
+		return getJavaNodeByRef(obj);
 	}
 
 	public void reloadCodeData() {

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

@@ -8,8 +8,13 @@ import java.util.List;
 import java.util.Map;
 
 import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.AnonymousClassAttr;
@@ -17,8 +22,10 @@ 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 jadx.core.utils.ListUtils;
 
 public final class JavaClass implements JavaNode {
+	private static final Logger LOG = LoggerFactory.getLogger(JavaClass.class);
 
 	private final JadxDecompiler decompiler;
 	private final ClassNode cls;
@@ -46,24 +53,21 @@ public final class JavaClass implements JavaNode {
 	}
 
 	public String getCode() {
-		ICodeInfo code = getCodeInfo();
+		return getCodeInfo().getCodeStr();
-		if (code == null) {
-			return "";
-		}
-		return code.getCodeStr();
 	}
 
-	public ICodeInfo getCodeInfo() {
+	public @NotNull ICodeInfo getCodeInfo() {
+		load();
 		return cls.decompile();
 	}
 
 	public void decompile() {
-		cls.decompile();
+		load();
 	}
 
-	public synchronized void reload() {
+	public synchronized ICodeInfo reload() {
 		listsLoaded = false;
-		cls.reloadCode();
+		return cls.reloadCode();
 	}
 
 	public void unload() {
@@ -75,10 +79,22 @@ public final class JavaClass implements JavaNode {
 		return cls.contains(AFlag.DONT_GENERATE);
 	}
 
+	public boolean isInner() {
+		return cls.isInner();
+	}
+
 	public synchronized String getSmali() {
 		return cls.getDisassembledCode();
 	}
 
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.CLASS) {
+			return ann.equals(cls);
+		}
+		return false;
+	}
+
 	/**
 	 * Internal API. Not Stable!
 	 */
@@ -87,13 +103,21 @@ public final class JavaClass implements JavaNode {
 		return cls;
 	}
 
-	private synchronized void loadLists() {
+	/**
+	 * Decompile class and loads internal lists of fields, methods, etc.
+	 * Do nothing if already loaded.
+	 */
+	@Nullable
+	private synchronized void load() {
 		if (listsLoaded) {
 			return;
 		}
 		listsLoaded = true;
-		decompile();
 		JadxDecompiler rootDecompiler = getRootDecompiler();
+		ICodeCache codeCache = rootDecompiler.getArgs().getCodeCache();
+		if (!codeCache.contains(cls.getRawName())) {
+			cls.decompile();
+		}
 
 		int inClsCount = cls.getInnerClasses().size();
 		if (inClsCount != 0) {
@@ -101,7 +125,7 @@ public final class JavaClass implements JavaNode {
 			for (ClassNode inner : cls.getInnerClasses()) {
 				if (!inner.contains(AFlag.DONT_GENERATE)) {
 					JavaClass javaClass = rootDecompiler.convertClassNode(inner);
-					javaClass.loadLists();
+					javaClass.load();
 					list.add(javaClass);
 				}
 			}
@@ -112,7 +136,7 @@ public final class JavaClass implements JavaNode {
 			List<JavaClass> list = new ArrayList<>(inlinedClsCount);
 			for (ClassNode inner : cls.getInlinedClasses()) {
 				JavaClass javaClass = rootDecompiler.convertClassNode(inner);
-				javaClass.loadLists();
+				javaClass.load();
 				list.add(javaClass);
 			}
 			this.inlinedClasses = Collections.unmodifiableList(list);
@@ -123,8 +147,7 @@ public final class JavaClass implements JavaNode {
 			List<JavaField> flds = new ArrayList<>(fieldsCount);
 			for (FieldNode f : cls.getFields()) {
 				if (!f.contains(AFlag.DONT_GENERATE)) {
-					JavaField javaField = new JavaField(this, f);
+					flds.add(rootDecompiler.convertFieldNode(f));
-					flds.add(javaField);
 				}
 			}
 			this.fields = Collections.unmodifiableList(flds);
@@ -135,8 +158,7 @@ public final class JavaClass implements JavaNode {
 			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(rootDecompiler.convertMethodNode(m));
-					mths.add(javaMethod);
 				}
 			}
 			mths.sort(Comparator.comparing(JavaMethod::getName));
@@ -144,56 +166,47 @@ public final class JavaClass implements JavaNode {
 		}
 	}
 
-	protected JadxDecompiler getRootDecompiler() {
+	JadxDecompiler getRootDecompiler() {
 		if (parent != null) {
 			return parent.getRootDecompiler();
 		}
 		return decompiler;
 	}
 
-	public Map<CodePosition, Object> getCodeAnnotations() {
+	public ICodeAnnotation getAnnotationAt(int pos) {
-		ICodeInfo code = getCodeInfo();
+		return getCodeInfo().getCodeMetadata().getAt(pos);
-		if (code == null) {
-			return Collections.emptyMap();
-		}
-		return code.getAnnotations();
 	}
 
-	public Object getAnnotationAt(CodePosition pos) {
+	public Map<Integer, JavaNode> getUsageMap() {
-		return getCodeAnnotations().get(pos);
+		Map<Integer, ICodeAnnotation> map = getCodeInfo().getCodeMetadata().getAsMap();
-	}
-
-	public Map<CodePosition, JavaNode> getUsageMap() {
-		Map<CodePosition, Object> map = getCodeAnnotations();
 		if (map.isEmpty() || decompiler == null) {
 			return Collections.emptyMap();
 		}
-		Map<CodePosition, JavaNode> resultMap = new HashMap<>(map.size());
+		Map<Integer, JavaNode> resultMap = new HashMap<>(map.size());
-		for (Map.Entry<CodePosition, Object> entry : map.entrySet()) {
+		for (Map.Entry<Integer, ICodeAnnotation> entry : map.entrySet()) {
-			CodePosition codePosition = entry.getKey();
+			int codePosition = entry.getKey();
-			Object obj = entry.getValue();
+			ICodeAnnotation obj = entry.getValue();
-			JavaNode node = getRootDecompiler().convertNode(obj);
+			if (obj instanceof ICodeNodeRef) {
-			if (node != null) {
+				JavaNode node = getRootDecompiler().getJavaNodeByRef((ICodeNodeRef) obj);
-				resultMap.put(codePosition, node);
+				if (node != null) {
+					resultMap.put(codePosition, node);
+				}
 			}
 		}
 		return resultMap;
 	}
 
-	public List<CodePosition> getUsageFor(JavaNode javaNode) {
+	public List<Integer> getUsePlacesFor(ICodeInfo codeInfo, JavaNode javaNode) {
-		Map<CodePosition, Object> map = getCodeAnnotations();
+		if (!codeInfo.hasMetadata()) {
-		if (map.isEmpty() || decompiler == null) {
 			return Collections.emptyList();
 		}
-		Object internalNode = getRootDecompiler().getInternalNode(javaNode);
+		List<Integer> result = new ArrayList<>();
-		List<CodePosition> result = new ArrayList<>();
+		codeInfo.getCodeMetadata().searchDown(0, (pos, ann) -> {
-		for (Map.Entry<CodePosition, Object> entry : map.entrySet()) {
+			if (javaNode.isOwnCodeAnnotation(ann)) {
-			CodePosition codePosition = entry.getKey();
+				result.add(pos);
-			Object obj = entry.getValue();
-			if (internalNode.equals(obj)) {
-				result.add(codePosition);
 			}
-		}
+			return null;
+		});
 		return result;
 	}
 
@@ -202,20 +215,8 @@ public final class JavaClass implements JavaNode {
 		return getRootDecompiler().convertNodes(cls.getUseIn());
 	}
 
-	@Nullable
-	@Deprecated
-	public JavaNode getJavaNodeAtPosition(int line, int offset) {
-		return getRootDecompiler().getJavaNodeAtPosition(getCodeInfo(), line, offset);
-	}
-
-	@Nullable
-	@Deprecated
-	public CodePosition getDefinitionPosition() {
-		return getRootDecompiler().getDefinitionPosition(this);
-	}
-
 	public Integer getSourceLine(int decompiledLine) {
-		return getCodeInfo().getLineMapping().get(decompiledLine);
+		return getCodeInfo().getCodeMetadata().getLineMapping().get(decompiledLine);
 	}
 
 	@Override
@@ -261,22 +262,22 @@ public final class JavaClass implements JavaNode {
 	}
 
 	public List<JavaClass> getInnerClasses() {
-		loadLists();
+		load();
 		return innerClasses;
 	}
 
 	public List<JavaClass> getInlinedClasses() {
-		loadLists();
+		load();
 		return inlinedClasses;
 	}
 
 	public List<JavaField> getFields() {
-		loadLists();
+		load();
 		return fields;
 	}
 
 	public List<JavaMethod> getMethods() {
-		loadLists();
+		load();
 		return methods;
 	}
 
@@ -286,7 +287,16 @@ public final class JavaClass implements JavaNode {
 		if (methodNode == null) {
 			return null;
 		}
-		return new JavaMethod(this, methodNode);
+		return getRootDecompiler().convertMethodNode(methodNode);
+	}
+
+	public List<JavaClass> getDependencies() {
+		JadxDecompiler d = getRootDecompiler();
+		return ListUtils.map(cls.getDependencies(), d::convertClassNode);
+	}
+
+	public int getTotalDepsCount() {
+		return cls.getTotalDepsCount();
 	}
 
 	@Override
@@ -294,11 +304,6 @@ public final class JavaClass implements JavaNode {
 		this.cls.getClassInfo().removeAlias();
 	}
 
-	@Override
-	public int getDecompiledLine() {
-		return cls.getDecompiledLine();
-	}
-
 	@Override
 	public int getDefPos() {
 		return cls.getDefPosition();

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

@@ -4,6 +4,7 @@ import java.util.List;
 
 import org.jetbrains.annotations.ApiStatus;
 
+import jadx.api.metadata.ICodeAnnotation;
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.FieldNode;
@@ -50,11 +51,6 @@ public final class JavaField implements JavaNode {
 		return ArgType.tryToResolveClassAlias(field.root(), field.getType());
 	}
 
-	@Override
-	public int getDecompiledLine() {
-		return field.getDecompiledLine();
-	}
-
 	@Override
 	public int getDefPos() {
 		return field.getDefPosition();
@@ -70,6 +66,14 @@ public final class JavaField implements JavaNode {
 		this.field.getFieldInfo().removeAlias();
 	}
 
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.FIELD) {
+			return ann.equals(field);
+		}
+		return false;
+	}
+
 	/**
 	 * Internal API. Not Stable!
 	 */

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

@@ -9,6 +9,7 @@ import org.jetbrains.annotations.ApiStatus;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.metadata.ICodeAnnotation;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.MethodOverrideAttr;
 import jadx.core.dex.info.AccessInfo;
@@ -18,6 +19,7 @@ import jadx.core.utils.Utils;
 
 public final class JavaMethod implements JavaNode {
 	private static final Logger LOG = LoggerFactory.getLogger(JavaMethod.class);
+
 	private final MethodNode mth;
 	private final JavaClass parent;
 
@@ -78,7 +80,7 @@ public final class JavaMethod implements JavaNode {
 		JadxDecompiler decompiler = getDeclaringClass().getRootDecompiler();
 		return ovrdAttr.getRelatedMthNodes().stream()
 				.map(m -> {
-					JavaMethod javaMth = (JavaMethod) decompiler.convertNode(m);
+					JavaMethod javaMth = decompiler.convertMethodNode(m);
 					if (javaMth == null) {
 						LOG.warn("Failed convert to java method: {}", m);
 					}
@@ -96,11 +98,6 @@ public final class JavaMethod implements JavaNode {
 		return mth.getMethodInfo().isClassInit();
 	}
 
-	@Override
-	public int getDecompiledLine() {
-		return mth.getDecompiledLine();
-	}
-
 	@Override
 	public int getDefPos() {
 		return mth.getDefPosition();
@@ -111,6 +108,14 @@ public final class JavaMethod implements JavaNode {
 		this.mth.getMethodInfo().removeAlias();
 	}
 
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.METHOD) {
+			return ann.equals(mth);
+		}
+		return false;
+	}
+
 	/**
 	 * Internal API. Not Stable!
 	 */

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

@@ -2,6 +2,8 @@ package jadx.api;
 
 import java.util.List;
 
+import jadx.api.metadata.ICodeAnnotation;
+
 public interface JavaNode {
 
 	String getName();
@@ -12,12 +14,12 @@ public interface JavaNode {
 
 	JavaClass getTopParentClass();
 
-	int getDecompiledLine();
-
 	int getDefPos();
 
 	List<JavaNode> getUseIn();
 
 	default void removeAlias() {
 	}
+
+	boolean isOwnCodeAnnotation(ICodeAnnotation ann);
 }

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

@@ -5,6 +5,8 @@ import java.util.List;
 
 import org.jetbrains.annotations.NotNull;
 
+import jadx.api.metadata.ICodeAnnotation;
+
 public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 	private final String name;
 	private final List<JavaClass> classes;
@@ -39,11 +41,6 @@ public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 		return null;
 	}
 
-	@Override
-	public int getDecompiledLine() {
-		return 0;
-	}
-
 	@Override
 	public int getDefPos() {
 		return 0;
@@ -54,6 +51,11 @@ public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 		return Collections.emptyList();
 	}
 
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		return false;
+	}
+
 	@Override
 	public int compareTo(@NotNull JavaPackage o) {
 		return name.compareTo(o.name);

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

@@ -5,16 +5,18 @@ import java.util.List;
 
 import org.jetbrains.annotations.ApiStatus;
 
-import jadx.api.data.annotations.VarDeclareRef;
+import jadx.api.metadata.ICodeAnnotation;
-import jadx.api.data.annotations.VarRef;
+import jadx.api.metadata.annotations.VarNode;
+import jadx.api.metadata.annotations.VarRef;
+import jadx.core.dex.instructions.args.ArgType;
 
 public class JavaVariable implements JavaNode {
 	private final JavaMethod mth;
-	private final VarRef varRef;
+	private final VarNode varNode;
 
-	public JavaVariable(JavaMethod mth, VarRef varRef) {
+	public JavaVariable(JavaMethod mth, VarNode varNode) {
 		this.mth = mth;
-		this.varRef = varRef;
+		this.varNode = varNode;
 	}
 
 	public JavaMethod getMth() {
@@ -22,26 +24,30 @@ public class JavaVariable implements JavaNode {
 	}
 
 	public int getReg() {
-		return varRef.getReg();
+		return varNode.getReg();
 	}
 
 	public int getSsa() {
-		return varRef.getSsa();
+		return varNode.getSsa();
 	}
 
 	@Override
 	public String getName() {
-		return varRef.getName();
+		return varNode.getName();
 	}
 
 	@ApiStatus.Internal
-	public VarRef getVarRef() {
+	public VarNode getVarNode() {
-		return varRef;
+		return varNode;
 	}
 
 	@Override
 	public String getFullName() {
-		return varRef.getType() + " " + varRef.getName() + " (r" + varRef.getReg() + "v" + varRef.getSsa() + ")";
+		return varNode.getType() + " " + varNode.getName() + " (r" + varNode.getReg() + "v" + varNode.getSsa() + ")";
+	}
+
+	public ArgType getType() {
+		return ArgType.tryToResolveClassAlias(mth.getMethodNode().root(), varNode.getType());
 	}
 
 	@Override
@@ -54,20 +60,9 @@ public class JavaVariable implements JavaNode {
 		return mth.getTopParentClass();
 	}
 
-	@Override
-	public int getDecompiledLine() {
-		if (varRef instanceof VarDeclareRef) {
-			return ((VarDeclareRef) varRef).getDecompiledLine();
-		}
-		return 0;
-	}
-
 	@Override
 	public int getDefPos() {
-		if (varRef instanceof VarDeclareRef) {
+		return varNode.getDefPosition();
-			return ((VarDeclareRef) varRef).getDefPosition();
-		}
-		return 0;
 	}
 
 	@Override
@@ -75,9 +70,18 @@ public class JavaVariable implements JavaNode {
 		return Collections.singletonList(mth);
 	}
 
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.VAR_REF) {
+			VarRef varRef = (VarRef) ann;
+			return varRef.getRefPos() == getDefPos();
+		}
+		return false;
+	}
+
 	@Override
 	public int hashCode() {
-		return varRef.hashCode();
+		return varNode.hashCode();
 	}
 
 	@Override
@@ -88,6 +92,6 @@ public class JavaVariable implements JavaNode {
 		if (!(o instanceof JavaVariable)) {
 			return false;
 		}
-		return varRef.equals(((JavaVariable) o).varRef);
+		return varNode.equals(((JavaVariable) o).varNode);
 	}
 }

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

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

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

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

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

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

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

@@ -3,7 +3,7 @@ package jadx.api.data.impl;
 import jadx.api.JavaVariable;
 import jadx.api.data.CodeRefType;
 import jadx.api.data.IJavaCodeRef;
-import jadx.api.data.annotations.VarRef;
+import jadx.api.metadata.annotations.VarNode;
 
 public class JadxCodeRef implements IJavaCodeRef {
 
@@ -23,8 +23,8 @@ public class JadxCodeRef implements IJavaCodeRef {
 		return forVar(javaVariable.getReg(), javaVariable.getSsa());
 	}
 
-	public static JadxCodeRef forVar(VarRef varRef) {
+	public static JadxCodeRef forVar(VarNode varNode) {
-		return forVar(varRef.getReg(), varRef.getSsa());
+		return forVar(varNode.getReg(), varNode.getSsa());
 	}
 
 	public static JadxCodeRef forCatch(int handlerOffset) {

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

@@ -2,23 +2,19 @@ package jadx.api.impl;
 
 import java.util.Map;
 
-import jadx.api.CodePosition;
 import jadx.api.ICodeInfo;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeMetadata;
+import jadx.api.metadata.impl.CodeMetadataStorage;
 
 public class AnnotatedCodeInfo implements ICodeInfo {
 
 	private final String code;
-	private final Map<Integer, Integer> lineMapping;
+	private final ICodeMetadata metadata;
-	private final Map<CodePosition, Object> annotations;
 
-	public AnnotatedCodeInfo(ICodeInfo codeInfo) {
+	public AnnotatedCodeInfo(String code, Map<Integer, Integer> lineMapping, Map<Integer, ICodeAnnotation> annotations) {
-		this(codeInfo.getCodeStr(), codeInfo.getLineMapping(), codeInfo.getAnnotations());
-	}
-
-	public AnnotatedCodeInfo(String code, Map<Integer, Integer> lineMapping, Map<CodePosition, Object> annotations) {
 		this.code = code;
-		this.lineMapping = lineMapping;
+		this.metadata = CodeMetadataStorage.build(lineMapping, annotations);
-		this.annotations = annotations;
 	}
 
 	@Override
@@ -27,13 +23,13 @@ public class AnnotatedCodeInfo implements ICodeInfo {
 	}
 
 	@Override
-	public Map<Integer, Integer> getLineMapping() {
+	public ICodeMetadata getCodeMetadata() {
-		return lineMapping;
+		return metadata;
 	}
 
 	@Override
-	public Map<CodePosition, Object> getAnnotations() {
+	public boolean hasMetadata() {
-		return annotations;
+		return metadata != ICodeMetadata.EMPTY;
 	}
 
 	@Override

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

@@ -5,18 +5,20 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.TreeMap;
 
-import jadx.api.CodePosition;
 import jadx.api.ICodeInfo;
 import jadx.api.ICodeWriter;
 import jadx.api.JadxArgs;
-import jadx.core.dex.attributes.ILineAttributeNode;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.api.metadata.annotations.NodeDeclareRef;
+import jadx.api.metadata.annotations.VarRef;
 import jadx.core.utils.StringUtils;
 
 public class AnnotatedCodeWriter extends SimpleCodeWriter implements ICodeWriter {
 
 	private int line = 1;
 	private int offset;
-	private Map<CodePosition, Object> annotations = Collections.emptyMap();
+	private Map<Integer, ICodeAnnotation> annotations = Collections.emptyMap();
 	private Map<Integer, Integer> lineMap = Collections.emptyMap();
 
 	public AnnotatedCodeWriter() {
@@ -59,19 +61,17 @@ public class AnnotatedCodeWriter extends SimpleCodeWriter implements ICodeWriter
 
 	@Override
 	public ICodeWriter add(ICodeWriter cw) {
-		if ((!(cw instanceof AnnotatedCodeWriter))) {
+		if (!cw.isMetadataSupported()) {
 			buf.append(cw.getCodeStr());
 			return this;
 		}
 		AnnotatedCodeWriter code = ((AnnotatedCodeWriter) cw);
 		line--;
-		int startLine = line;
 		int startPos = getLength();
-		for (Map.Entry<CodePosition, Object> entry : code.annotations.entrySet()) {
+		for (Map.Entry<Integer, ICodeAnnotation> entry : code.annotations.entrySet()) {
-			CodePosition codePos = entry.getKey();
+			int pos = entry.getKey();
-			int newLine = startLine + codePos.getLine();
+			int newPos = startPos + pos;
-			int newPos = startPos + codePos.getPos();
+			attachAnnotation(entry.getValue(), newPos);
-			attachAnnotation(entry.getValue(), new CodePosition(newLine, codePos.getOffset(), newPos));
 		}
 		for (Map.Entry<Integer, Integer> entry : code.lineMap.entrySet()) {
 			attachSourceLine(line + entry.getKey(), entry.getValue());
@@ -101,44 +101,36 @@ public class AnnotatedCodeWriter extends SimpleCodeWriter implements ICodeWriter
 		return line;
 	}
 
-	private static final class DefinitionWrapper {
+	@Override
-		private final ILineAttributeNode node;
+	public int getLineStartPos() {
-
+		return getLength() - offset;
-		private DefinitionWrapper(ILineAttributeNode node) {
-			this.node = node;
-		}
-
-		public ILineAttributeNode getNode() {
-			return node;
-		}
 	}
 
 	@Override
-	public void attachDefinition(ILineAttributeNode obj) {
+	public void attachDefinition(ICodeNodeRef obj) {
 		if (obj == null) {
 			return;
 		}
-		attachAnnotation(obj);
+		attachAnnotation(new NodeDeclareRef(obj));
-		attachAnnotation(new DefinitionWrapper(obj), new CodePosition(line, offset, getLength()));
 	}
 
 	@Override
-	public void attachAnnotation(Object obj) {
+	public void attachAnnotation(ICodeAnnotation obj) {
 		if (obj == null) {
 			return;
 		}
-		attachAnnotation(obj, new CodePosition(line, offset + 1, getLength()));
+		attachAnnotation(obj, getLength());
 	}
 
 	@Override
-	public void attachLineAnnotation(Object obj) {
+	public void attachLineAnnotation(ICodeAnnotation obj) {
 		if (obj == null) {
 			return;
 		}
-		attachAnnotation(obj, new CodePosition(line, 0, getLength() - offset));
+		attachAnnotation(obj, getLineStartPos());
 	}
 
-	private void attachAnnotation(Object obj, CodePosition pos) {
+	private void attachAnnotation(ICodeAnnotation obj, int pos) {
 		if (annotations.isEmpty()) {
 			annotations = new HashMap<>();
 		}
@@ -164,29 +156,39 @@ public class AnnotatedCodeWriter extends SimpleCodeWriter implements ICodeWriter
 	public ICodeInfo finish() {
 		removeFirstEmptyLine();
 		processDefinitionAnnotations();
+		validateAnnotations();
 		String code = buf.toString();
 		buf = null;
 		return new AnnotatedCodeInfo(code, lineMap, annotations);
 	}
 
 	@Override
-	public Map<CodePosition, Object> getRawAnnotations() {
+	public Map<Integer, ICodeAnnotation> getRawAnnotations() {
 		return annotations;
 	}
 
 	private void processDefinitionAnnotations() {
 		if (!annotations.isEmpty()) {
-			annotations.entrySet().removeIf(entry -> {
+			annotations.forEach((k, v) -> {
-				Object v = entry.getValue();
+				if (v instanceof NodeDeclareRef) {
-				if (v instanceof DefinitionWrapper) {
+					NodeDeclareRef declareRef = (NodeDeclareRef) v;
-					ILineAttributeNode l = ((DefinitionWrapper) v).getNode();
+					declareRef.setDefPos(k);
-					CodePosition codePos = entry.getKey();
+					declareRef.getNode().setDefPosition(k);
-					l.setDecompiledLine(codePos.getLine());
-					l.setDefPosition(codePos.getPos());
-					return true;
 				}
-				return false;
 			});
 		}
 	}
+
+	private void validateAnnotations() {
+		if (annotations.isEmpty()) {
+			return;
+		}
+		annotations.values().removeIf(v -> {
+			if (v.getAnnType() == ICodeAnnotation.AnnType.VAR_REF) {
+				VarRef varRef = (VarRef) v;
+				return varRef.getRefPos() == 0;
+			}
+			return false;
+		});
+	}
 }

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

@@ -0,0 +1,49 @@
+package jadx.api.impl;
+
+import java.io.IOException;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.ICodeCache;
+import jadx.api.ICodeInfo;
+
+public abstract class DelegateCodeCache implements ICodeCache {
+
+	protected final ICodeCache backCache;
+
+	public DelegateCodeCache(ICodeCache backCache) {
+		this.backCache = backCache;
+	}
+
+	@Override
+	public void add(String clsFullName, ICodeInfo codeInfo) {
+		backCache.add(clsFullName, codeInfo);
+	}
+
+	@Override
+	public void remove(String clsFullName) {
+		backCache.remove(clsFullName);
+	}
+
+	@Override
+	public @NotNull ICodeInfo get(String clsFullName) {
+		return backCache.get(clsFullName);
+	}
+
+	@Override
+	@Nullable
+	public String getCode(String clsFullName) {
+		return backCache.getCode(clsFullName);
+	}
+
+	@Override
+	public boolean contains(String clsFullName) {
+		return backCache.contains(clsFullName);
+	}
+
+	@Override
+	public void close() throws IOException {
+		backCache.close();
+	}
+}

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

@@ -1,8 +1,10 @@
 package jadx.api.impl;
 
+import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import jadx.api.ICodeCache;
@@ -22,9 +24,33 @@ public class InMemoryCodeCache implements ICodeCache {
 		storage.remove(clsFullName);
 	}
 
+	@NotNull
 	@Override
-	public @Nullable ICodeInfo get(String clsFullName) {
+	public ICodeInfo get(String clsFullName) {
-		return storage.get(clsFullName);
+		ICodeInfo codeInfo = storage.get(clsFullName);
+		if (codeInfo == null) {
+			return ICodeInfo.EMPTY;
+		}
+		return codeInfo;
+	}
+
+	@Override
+	public @Nullable String getCode(String clsFullName) {
+		ICodeInfo codeInfo = storage.get(clsFullName);
+		if (codeInfo == null) {
+			return null;
+		}
+		return codeInfo.getCodeStr();
+	}
+
+	@Override
+	public boolean contains(String clsFullName) {
+		return storage.containsKey(clsFullName);
+	}
+
+	@Override
+	public void close() throws IOException {
+		storage.clear();
 	}
 
 	@Override

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

@@ -1,5 +1,6 @@
 package jadx.api.impl;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import jadx.api.ICodeCache;
@@ -7,6 +8,8 @@ import jadx.api.ICodeInfo;
 
 public class NoOpCodeCache implements ICodeCache {
 
+	public static final NoOpCodeCache INSTANCE = new NoOpCodeCache();
+
 	@Override
 	public void add(String clsFullName, ICodeInfo codeInfo) {
 		// do nothing
@@ -18,10 +21,26 @@ public class NoOpCodeCache implements ICodeCache {
 	}
 
 	@Override
-	public @Nullable ICodeInfo get(String clsFullName) {
+	@NotNull
+	public ICodeInfo get(String clsFullName) {
+		return ICodeInfo.EMPTY;
+	}
+
+	@Override
+	public @Nullable String getCode(String clsFullName) {
 		return null;
 	}
 
+	@Override
+	public boolean contains(String clsFullName) {
+		return false;
+	}
+
+	@Override
+	public void close() {
+		// do nothing
+	}
+
 	@Override
 	public String toString() {
 		return "NoOpCodeCache";

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

@@ -1,10 +1,7 @@
 package jadx.api.impl;
 
-import java.util.Collections;
-import java.util.Map;
-
-import jadx.api.CodePosition;
 import jadx.api.ICodeInfo;
+import jadx.api.metadata.ICodeMetadata;
 
 public class SimpleCodeInfo implements ICodeInfo {
 
@@ -20,13 +17,13 @@ public class SimpleCodeInfo implements ICodeInfo {
 	}
 
 	@Override
-	public Map<Integer, Integer> getLineMapping() {
+	public ICodeMetadata getCodeMetadata() {
-		return Collections.emptyMap();
+		return ICodeMetadata.EMPTY;
 	}
 
 	@Override
-	public Map<CodePosition, Object> getAnnotations() {
+	public boolean hasMetadata() {
-		return Collections.emptyMap();
+		return false;
 	}
 
 	@Override

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

@@ -6,11 +6,11 @@ import java.util.Map;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import jadx.api.CodePosition;
 import jadx.api.ICodeInfo;
 import jadx.api.ICodeWriter;
 import jadx.api.JadxArgs;
-import jadx.core.dex.attributes.ILineAttributeNode;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
 import jadx.core.utils.Utils;
 
 /**
@@ -193,17 +193,22 @@ public class SimpleCodeWriter implements ICodeWriter {
 	}
 
 	@Override
-	public void attachDefinition(ILineAttributeNode obj) {
+	public int getLineStartPos() {
+		return 0;
+	}
+
+	@Override
+	public void attachDefinition(ICodeNodeRef obj) {
 		// no op
 	}
 
 	@Override
-	public void attachAnnotation(Object obj) {
+	public void attachAnnotation(ICodeAnnotation obj) {
 		// no op
 	}
 
 	@Override
-	public void attachLineAnnotation(Object obj) {
+	public void attachLineAnnotation(ICodeAnnotation obj) {
 		// no op
 	}
 
@@ -238,7 +243,7 @@ public class SimpleCodeWriter implements ICodeWriter {
 	}
 
 	@Override
-	public Map<CodePosition, Object> getRawAnnotations() {
+	public Map<Integer, ICodeAnnotation> getRawAnnotations() {
 		return Collections.emptyMap();
 	}
 

jadx-core/src/main/java/jadx/api/metadata/ICodeAnnotation.java

@@ -0,0 +1,16 @@
+package jadx.api.metadata;
+
+public interface ICodeAnnotation {
+
+	enum AnnType {
+		CLASS,
+		FIELD,
+		METHOD,
+		VAR,
+		VAR_REF,
+		DECLARATION,
+		OFFSET
+	}
+
+	AnnType getAnnType();
+}

jadx-core/src/main/java/jadx/api/metadata/ICodeMetadata.java

@@ -0,0 +1,59 @@
+package jadx.api.metadata;
+
+import java.util.Map;
+import java.util.function.BiFunction;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.metadata.impl.CodeMetadataStorage;
+
+public interface ICodeMetadata {
+
+	ICodeMetadata EMPTY = CodeMetadataStorage.empty();
+
+	@Nullable
+	ICodeAnnotation getAt(int position);
+
+	@Nullable
+	ICodeAnnotation getClosestUp(int position);
+
+	@Nullable
+	ICodeAnnotation searchUp(int position, ICodeAnnotation.AnnType annType);
+
+	@Nullable
+	ICodeAnnotation searchUp(int position, int limitPos, ICodeAnnotation.AnnType annType);
+
+	/**
+	 * Iterate code annotations from {@code startPos} to smaller positions.
+	 *
+	 * @param visitor
+	 *                return not null value to stop iterations
+	 */
+	@Nullable
+	<T> T searchUp(int startPos, BiFunction<Integer, ICodeAnnotation, T> visitor);
+
+	/**
+	 * Iterate code annotations from {@code startPos} to higher positions.
+	 *
+	 * @param visitor
+	 *                return not null value to stop iterations
+	 */
+	@Nullable
+	<T> T searchDown(int startPos, BiFunction<Integer, ICodeAnnotation, T> visitor);
+
+	/**
+	 * Get current node at position (can be enclosing class or method)
+	 */
+	@Nullable
+	ICodeNodeRef getNodeAt(int position);
+
+	/**
+	 * Any definition of class or method below position
+	 */
+	@Nullable
+	ICodeNodeRef getNodeBelow(int position);
+
+	Map<Integer, ICodeAnnotation> getAsMap();
+
+	Map<Integer, Integer> getLineMapping();
+}

jadx-core/src/main/java/jadx/api/metadata/ICodeNodeRef.java

@@ -0,0 +1,7 @@
+package jadx.api.metadata;
+
+public interface ICodeNodeRef extends ICodeAnnotation {
+	int getDefPosition();
+
+	void setDefPosition(int pos);
+}

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

@@ -1,11 +1,12 @@
-package jadx.api.data.annotations;
+package jadx.api.metadata.annotations;
 
 import org.jetbrains.annotations.Nullable;
 
 import jadx.api.ICodeWriter;
+import jadx.api.metadata.ICodeAnnotation;
 import jadx.core.dex.nodes.InsnNode;
 
-public class InsnCodeOffset implements ICodeRawOffset {
+public class InsnCodeOffset implements ICodeAnnotation {
 
 	public static void attach(ICodeWriter code, InsnNode insn) {
 		if (insn == null) {
@@ -40,11 +41,15 @@ public class InsnCodeOffset implements ICodeRawOffset {
 		this.offset = offset;
 	}
 
-	@Override
 	public int getOffset() {
 		return offset;
 	}
 
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.OFFSET;
+	}
+
 	@Override
 	public String toString() {
 		return "offset=" + offset;

jadx-core/src/main/java/jadx/api/metadata/annotations/NodeDeclareRef.java

@@ -0,0 +1,39 @@
+package jadx.api.metadata.annotations;
+
+import java.util.Objects;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+
+public class NodeDeclareRef implements ICodeAnnotation {
+
+	private final ICodeNodeRef node;
+
+	private int defPos;
+
+	public NodeDeclareRef(ICodeNodeRef node) {
+		this.node = Objects.requireNonNull(node);
+	}
+
+	public ICodeNodeRef getNode() {
+		return node;
+	}
+
+	public int getDefPos() {
+		return defPos;
+	}
+
+	public void setDefPos(int defPos) {
+		this.defPos = defPos;
+	}
+
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.DECLARATION;
+	}
+
+	@Override
+	public String toString() {
+		return "NodeDeclareRef{" + node + '}';
+	}
+}

jadx-core/src/main/java/jadx/api/metadata/annotations/VarNode.java

@@ -0,0 +1,147 @@
+package jadx.api.metadata.annotations;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.instructions.args.CodeVar;
+import jadx.core.dex.instructions.args.RegisterArg;
+import jadx.core.dex.instructions.args.SSAVar;
+import jadx.core.dex.nodes.MethodNode;
+
+/**
+ * Variable info
+ */
+public class VarNode implements ICodeNodeRef {
+
+	@Nullable
+	public static VarNode get(MethodNode mth, RegisterArg reg) {
+		SSAVar ssaVar = reg.getSVar();
+		if (ssaVar == null) {
+			return null;
+		}
+		return get(mth, ssaVar);
+	}
+
+	@Nullable
+	public static VarNode get(MethodNode mth, CodeVar codeVar) {
+		return get(mth, codeVar.getAnySsaVar());
+	}
+
+	@Nullable
+	public static VarNode get(MethodNode mth, SSAVar ssaVar) {
+		CodeVar codeVar = ssaVar.getCodeVar();
+		if (codeVar.isThis()) {
+			return null;
+		}
+		VarNode cachedVarNode = codeVar.getCachedVarNode();
+		if (cachedVarNode != null) {
+			return cachedVarNode;
+		}
+		VarNode newVarNode = new VarNode(mth, ssaVar);
+		codeVar.setCachedVarNode(newVarNode);
+		return newVarNode;
+	}
+
+	@Nullable
+	public static ICodeAnnotation getRef(MethodNode mth, RegisterArg reg) {
+		VarNode varNode = get(mth, reg);
+		if (varNode == null) {
+			return null;
+		}
+		return varNode.getVarRef();
+	}
+
+	private final MethodNode mth;
+	private final int reg;
+	private final int ssa;
+	private final ArgType type;
+	private @Nullable String name;
+	private int defPos;
+
+	private final VarRef varRef;
+
+	protected VarNode(MethodNode mth, SSAVar ssaVar) {
+		this(mth, ssaVar.getRegNum(), ssaVar.getVersion(),
+				ssaVar.getCodeVar().getType(), ssaVar.getCodeVar().getName());
+	}
+
+	public VarNode(MethodNode mth, int reg, int ssa, ArgType type, String name) {
+		this.mth = mth;
+		this.reg = reg;
+		this.ssa = ssa;
+		this.type = type;
+		this.name = name;
+		this.varRef = VarRef.fromVarNode(this);
+	}
+
+	public MethodNode getMth() {
+		return mth;
+	}
+
+	public int getReg() {
+		return reg;
+	}
+
+	public int getSsa() {
+		return ssa;
+	}
+
+	public ArgType getType() {
+		return type;
+	}
+
+	@Nullable
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public VarRef getVarRef() {
+		return varRef;
+	}
+
+	@Override
+	public int getDefPosition() {
+		return defPos;
+	}
+
+	@Override
+	public void setDefPosition(int pos) {
+		this.defPos = pos;
+	}
+
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.VAR;
+	}
+
+	@Override
+	public int hashCode() {
+		int h = 31 * getReg() + getSsa();
+		return 31 * h + mth.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof VarNode)) {
+			return false;
+		}
+		VarNode other = (VarNode) o;
+		return getReg() == other.getReg()
+				&& getSsa() == other.getSsa()
+				&& getMth().equals(other.getMth());
+	}
+
+	@Override
+	public String toString() {
+		return "VarNode{r" + reg + 'v' + ssa + '}';
+	}
+}

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

@@ -0,0 +1,68 @@
+package jadx.api.metadata.annotations;
+
+import jadx.api.metadata.ICodeAnnotation;
+
+/**
+ * Variable reference by position of VarNode in code metadata.
+ * <br>
+ * Because on creation position not yet known,
+ * VarRef created using VarNode as a source of ref pos during serialization.
+ * <br>
+ * On metadata deserialization created with ref pos directly.
+ */
+public abstract class VarRef implements ICodeAnnotation {
+
+	public static VarRef fromPos(int refPos) {
+		if (refPos == 0) {
+			throw new IllegalArgumentException("Zero refPos");
+		}
+		return new FixedVarRef(refPos);
+	}
+
+	public static VarRef fromVarNode(VarNode varNode) {
+		return new RelatedVarRef(varNode);
+	}
+
+	public abstract int getRefPos();
+
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.VAR_REF;
+	}
+
+	public static final class FixedVarRef extends VarRef {
+		private final int refPos;
+
+		public FixedVarRef(int refPos) {
+			this.refPos = refPos;
+		}
+
+		@Override
+		public int getRefPos() {
+			return refPos;
+		}
+	}
+
+	public static final class RelatedVarRef extends VarRef {
+		private final VarNode varNode;
+
+		public RelatedVarRef(VarNode varNode) {
+			this.varNode = varNode;
+		}
+
+		@Override
+		public int getRefPos() {
+			return varNode.getDefPosition();
+		}
+
+		@Override
+		public String toString() {
+			return "VarRef{" + varNode + ", name=" + varNode.getName() + ", mth=" + varNode.getMth() + '}';
+		}
+	}
+
+	@Override
+	public String toString() {
+		return "VarRef{" + getRefPos() + '}';
+	}
+}

jadx-core/src/main/java/jadx/api/metadata/impl/CodeMetadataStorage.java

@@ -0,0 +1,141 @@
+package jadx.api.metadata.impl;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.TreeMap;
+import java.util.function.BiFunction;
+import java.util.stream.Stream;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeMetadata;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.api.metadata.annotations.NodeDeclareRef;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.utils.Utils;
+
+public class CodeMetadataStorage implements ICodeMetadata {
+
+	public static ICodeMetadata build(Map<Integer, Integer> lines, Map<Integer, ICodeAnnotation> map) {
+		if (map.isEmpty() && lines.isEmpty()) {
+			return ICodeMetadata.EMPTY;
+		}
+		Comparator<Integer> reverseCmp = Comparator.comparingInt(Integer::intValue).reversed();
+		NavigableMap<Integer, ICodeAnnotation> navMap = new TreeMap<>(reverseCmp);
+		navMap.putAll(map);
+		return new CodeMetadataStorage(lines, navMap);
+	}
+
+	public static ICodeMetadata empty() {
+		return new CodeMetadataStorage(Collections.emptyMap(), Collections.emptyNavigableMap());
+	}
+
+	private final Map<Integer, Integer> lines;
+
+	private final NavigableMap<Integer, ICodeAnnotation> navMap;
+
+	private CodeMetadataStorage(Map<Integer, Integer> lines, NavigableMap<Integer, ICodeAnnotation> navMap) {
+		this.lines = lines;
+		this.navMap = navMap;
+	}
+
+	@Override
+	public ICodeAnnotation getAt(int position) {
+		return navMap.get(position);
+	}
+
+	@Override
+	public @Nullable ICodeAnnotation getClosestUp(int position) {
+		Map.Entry<Integer, ICodeAnnotation> entryBefore = navMap.higherEntry(position);
+		return entryBefore != null ? entryBefore.getValue() : null;
+	}
+
+	@Override
+	public @Nullable ICodeAnnotation searchUp(int position, ICodeAnnotation.AnnType annType) {
+		for (ICodeAnnotation v : navMap.tailMap(position, true).values()) {
+			if (v.getAnnType() == annType) {
+				return v;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public @Nullable ICodeAnnotation searchUp(int position, int limitPos, ICodeAnnotation.AnnType annType) {
+		for (ICodeAnnotation v : navMap.subMap(position, true, limitPos, true).values()) {
+			if (v.getAnnType() == annType) {
+				return v;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public <T> @Nullable T searchUp(int startPos, BiFunction<Integer, ICodeAnnotation, T> visitor) {
+		for (Map.Entry<Integer, ICodeAnnotation> entry : navMap.tailMap(startPos, true).entrySet()) {
+			T value = visitor.apply(entry.getKey(), entry.getValue());
+			if (value != null) {
+				return value;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public <T> @Nullable T searchDown(int startPos, BiFunction<Integer, ICodeAnnotation, T> visitor) {
+		NavigableMap<Integer, ICodeAnnotation> map = navMap.headMap(startPos, true).descendingMap();
+		for (Map.Entry<Integer, ICodeAnnotation> entry : map.entrySet()) {
+			T value = visitor.apply(entry.getKey(), entry.getValue());
+			if (value != null) {
+				return value;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public ICodeNodeRef getNodeAt(int position) {
+		return navMap.tailMap(position, true)
+				.values().stream()
+				.flatMap(CodeMetadataStorage::mapEnclosingNode)
+				.findFirst().orElse(null);
+	}
+
+	@Override
+	public ICodeNodeRef getNodeBelow(int position) {
+		return navMap.headMap(position, true).descendingMap()
+				.values().stream()
+				.flatMap(CodeMetadataStorage::mapEnclosingNode)
+				.findFirst().orElse(null);
+	}
+
+	private static Stream<ICodeNodeRef> mapEnclosingNode(ICodeAnnotation ann) {
+		if (ann instanceof NodeDeclareRef) {
+			ICodeNodeRef node = ((NodeDeclareRef) ann).getNode();
+			if (node instanceof ClassNode || node instanceof MethodNode) {
+				return Stream.of(node);
+			}
+		}
+		return Stream.empty();
+	}
+
+	@Override
+	public NavigableMap<Integer, ICodeAnnotation> getAsMap() {
+		return navMap;
+	}
+
+	@Override
+	public Map<Integer, Integer> getLineMapping() {
+		return lines;
+	}
+
+	@Override
+	public String toString() {
+		return "CodeMetadata{lines=" + lines
+				+ ", annotations=\n" + Utils.listToString(navMap.entrySet(), "\n") + "\n}";
+	}
+}

jadx-core/src/main/java/jadx/api/utils/CodeUtils.java

@@ -0,0 +1,38 @@
+package jadx.api.utils;
+
+import jadx.api.ICodeWriter;
+
+public class CodeUtils {
+
+	public static String getLineForPos(String code, int pos) {
+		int start = getLineStartForPos(code, pos);
+		int end = getLineEndForPos(code, pos);
+		return code.substring(start, end);
+	}
+
+	public static int getLineStartForPos(String code, int pos) {
+		String newLine = ICodeWriter.NL;
+		int start = code.lastIndexOf(newLine, pos);
+		return start == -1 ? 0 : start + newLine.length();
+	}
+
+	public static int getLineEndForPos(String code, int pos) {
+		int end = code.indexOf(ICodeWriter.NL, pos);
+		return end == -1 ? code.length() : end;
+	}
+
+	public static int getLineNumForPos(String code, int pos) {
+		String newLine = ICodeWriter.NL;
+		int newLineLen = newLine.length();
+		int line = 1;
+		int prev = 0;
+		while (true) {
+			int next = code.indexOf(newLine, prev);
+			if (next >= pos) {
+				return line;
+			}
+			prev = next + newLineLen;
+			line++;
+		}
+	}
+}

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

@@ -99,6 +99,10 @@ public class ProcessClass {
 			return generateCode(topParentClass);
 		}
 		try {
+			if (cls.contains(AFlag.DONT_GENERATE)) {
+				process(cls, false);
+				return ICodeInfo.EMPTY;
+			}
 			for (ClassNode depCls : cls.getDependencies()) {
 				process(depCls, false);
 			}

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

@@ -11,9 +11,8 @@ import org.slf4j.LoggerFactory;
 
 import jadx.api.CommentsLevel;
 import jadx.api.ICodeWriter;
-import jadx.api.data.annotations.InsnCodeOffset;
+import jadx.api.metadata.annotations.InsnCodeOffset;
-import jadx.api.data.annotations.VarDeclareRef;
+import jadx.api.metadata.annotations.VarNode;
-import jadx.api.data.annotations.VarRef;
 import jadx.api.plugins.input.data.MethodHandleType;
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
@@ -109,7 +108,7 @@ public class InsnGen {
 		if (arg.isRegister()) {
 			RegisterArg reg = (RegisterArg) arg;
 			if (code.isMetadataSupported()) {
-				code.attachAnnotation(VarRef.get(mth, reg));
+				code.attachAnnotation(VarNode.getRef(mth, reg));
 			}
 			code.add(mgen.getNameGen().useArg(reg));
 		} else if (arg.isLiteral()) {
@@ -162,10 +161,18 @@ public class InsnGen {
 		}
 		useType(code, codeVar.getType());
 		code.add(' ');
+		defVar(code, codeVar);
+	}
+
+	/**
+	 * Variable definition without type, only var name
+	 */
+	private void defVar(ICodeWriter code, CodeVar codeVar) {
+		String varName = mgen.getNameGen().assignArg(codeVar);
 		if (code.isMetadataSupported()) {
-			code.attachDefinition(VarDeclareRef.get(mth, codeVar));
+			code.attachDefinition(VarNode.get(mth, codeVar));
 		}
-		code.add(mgen.getNameGen().assignArg(codeVar));
+		code.add(varName);
 	}
 
 	private String lit(LiteralArg arg) {
@@ -939,7 +946,7 @@ public class InsnGen {
 					code.add(", ");
 				}
 				CodeVar argCodeVar = callArgs.get(i).getSVar().getCodeVar();
-				code.add(nameGen.assignArg(argCodeVar));
+				defVar(code, argCodeVar);
 			}
 		}
 		// force set external arg names into call method args
@@ -947,7 +954,8 @@ public class InsnGen {
 		int startArg = customNode.getHandleType() == MethodHandleType.INVOKE_STATIC ? 0 : 1; // skip 'this' arg
 		for (int i = startArg; i < extArgsCount; i++) {
 			RegisterArg extArg = (RegisterArg) customNode.getArg(i);
-			callArgs.get(i).setName(extArg.getName());
+			RegisterArg callRegArg = callArgs.get(i);
+			callRegArg.getSVar().setCodeVar(extArg.getSVar().getCodeVar());
 		}
 		code.add(" -> {");
 		code.incIndent();

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

@@ -13,8 +13,8 @@ import org.slf4j.LoggerFactory;
 import jadx.api.CommentsLevel;
 import jadx.api.ICodeWriter;
 import jadx.api.JadxArgs;
-import jadx.api.data.annotations.InsnCodeOffset;
+import jadx.api.metadata.annotations.InsnCodeOffset;
-import jadx.api.data.annotations.VarDeclareRef;
+import jadx.api.metadata.annotations.VarNode;
 import jadx.api.plugins.input.data.AccessFlags;
 import jadx.api.plugins.input.data.annotations.EncodedValue;
 import jadx.api.plugins.input.data.attributes.JadxAttrType;
@@ -243,7 +243,7 @@ public class MethodGen {
 			code.add(' ');
 			String varName = nameGen.assignArg(var);
 			if (code.isMetadataSupported() && ssaVar != null /* for fallback mode */) {
-				code.attachDefinition(VarDeclareRef.get(mth, var));
+				code.attachDefinition(VarNode.get(mth, var));
 			}
 			code.add(varName);
 

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

@@ -7,6 +7,7 @@ import java.util.Set;
 
 import jadx.core.Consts;
 import jadx.core.deobf.NameMapper;
+import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.nodes.LoopLabelAttr;
 import jadx.core.dex.info.ClassInfo;
 import jadx.core.dex.info.MethodInfo;
@@ -173,7 +174,7 @@ public class NameGen {
 
 	private String makeNameForType(ArgType type) {
 		if (type.isPrimitive()) {
-			return makeNameForPrimitive(type);
+			return type.getPrimitiveType().getShortName().toLowerCase();
 		}
 		if (type.isArray()) {
 			return makeNameForType(type.getArrayRootElement()) + "Arr";
@@ -181,10 +182,6 @@ public class NameGen {
 		return makeNameForObject(type);
 	}
 
-	private static String makeNameForPrimitive(ArgType type) {
-		return type.getPrimitiveType().getShortName().toLowerCase();
-	}
-
 	private String makeNameForObject(ArgType type) {
 		if (type.isGenericType()) {
 			return StringUtils.escape(type.getObject().toLowerCase());
@@ -194,23 +191,32 @@ public class NameGen {
 			if (alias != null) {
 				return alias;
 			}
-			ClassInfo extClsInfo = ClassInfo.fromType(mth.root(), type);
+			return makeNameForCheckedClass(ClassInfo.fromType(mth.root(), type));
-			String shortName = extClsInfo.getShortName();
-			String vName = fromName(shortName);
-			if (vName != null) {
-				return vName;
-			}
-			if (shortName != null) {
-				String lower = StringUtils.escape(shortName.toLowerCase());
-				if (shortName.equals(lower)) {
-					return lower + "Var";
-				}
-				return lower;
-			}
 		}
 		return StringUtils.escape(type.toString());
 	}
 
+	private String makeNameForCheckedClass(ClassInfo classInfo) {
+		String shortName = classInfo.getAliasShortName();
+		String vName = fromName(shortName);
+		if (vName != null) {
+			return vName;
+		}
+		String lower = StringUtils.escape(shortName.toLowerCase());
+		if (shortName.equals(lower)) {
+			return lower + "Var";
+		}
+		return lower;
+	}
+
+	private String makeNameForClass(ClassInfo classInfo) {
+		String alias = getAliasForObject(classInfo.getFullName());
+		if (alias != null) {
+			return alias;
+		}
+		return makeNameForCheckedClass(classInfo);
+	}
+
 	private static String fromName(String name) {
 		if (name == null || name.isEmpty()) {
 			return null;
@@ -241,7 +247,12 @@ public class NameGen {
 
 			case CONSTRUCTOR:
 				ConstructorInsn co = (ConstructorInsn) insn;
-				return makeNameForObject(co.getClassType().getType());
+				MethodNode callMth = mth.root().getMethodUtils().resolveMethod(co);
+				if (callMth != null && callMth.contains(AFlag.ANONYMOUS_CONSTRUCTOR)) {
+					// don't use name of anonymous class
+					return null;
+				}
+				return makeNameForClass(co.getClassType());
 
 			case ARRAY_LENGTH:
 				return "length";
@@ -267,11 +278,11 @@ public class NameGen {
 	}
 
 	private String makeNameFromInvoke(MethodInfo callMth) {
-		String name = callMth.getName();
+		String name = callMth.getAlias();
-		ArgType declType = callMth.getDeclClass().getType();
+		ClassInfo declClass = callMth.getDeclClass();
 		if ("getInstance".equals(name)) {
 			// e.g. Cipher.getInstance
-			return makeNameForType(declType);
+			return makeNameForClass(declClass);
 		}
 		if (name.startsWith("get") || name.startsWith("set")) {
 			return fromName(name.substring(3));
@@ -280,9 +291,9 @@ public class NameGen {
 			return "it";
 		}
 		if ("toString".equals(name)) {
-			return makeNameForType(declType);
+			return makeNameForClass(declClass);
 		}
-		if ("forName".equals(name) && declType.equals(ArgType.CLASS)) {
+		if ("forName".equals(name) && declClass.getType().equals(ArgType.CLASS)) {
 			return OBJ_ALIAS.get(Consts.CLASS_CLASS);
 		}
 		if (name.startsWith("to")) {

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

@@ -10,8 +10,8 @@ import org.slf4j.LoggerFactory;
 
 import jadx.api.CommentsLevel;
 import jadx.api.ICodeWriter;
-import jadx.api.data.annotations.InsnCodeOffset;
+import jadx.api.metadata.annotations.InsnCodeOffset;
-import jadx.api.data.annotations.VarDeclareRef;
+import jadx.api.metadata.annotations.VarNode;
 import jadx.api.plugins.input.data.annotations.EncodedValue;
 import jadx.api.plugins.input.data.attributes.JadxAttrType;
 import jadx.core.dex.attributes.AFlag;
@@ -26,6 +26,7 @@ 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;
+import jadx.core.dex.instructions.args.SSAVar;
 import jadx.core.dex.nodes.BlockNode;
 import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.IBlock;
@@ -346,11 +347,11 @@ public class RegionGen extends InsnGen {
 		if (arg == null) {
 			code.add("unknown"); // throwing exception is too late at this point
 		} else if (arg instanceof RegisterArg) {
-			CodeVar codeVar = ((RegisterArg) arg).getSVar().getCodeVar();
+			SSAVar ssaVar = ((RegisterArg) arg).getSVar();
 			if (code.isMetadataSupported()) {
-				code.attachDefinition(VarDeclareRef.get(mth, codeVar));
+				code.attachDefinition(VarNode.get(mth, ssaVar));
 			}
-			code.add(mgen.getNameGen().assignArg(codeVar));
+			code.add(mgen.getNameGen().assignArg(ssaVar.getCodeVar()));
 		} else if (arg instanceof NamedArg) {
 			code.add(mgen.getNameGen().assignNamedArg((NamedArg) arg));
 		} else {

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

@@ -12,13 +12,13 @@ import com.google.gson.FieldNamingPolicy;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 
-import jadx.api.CodePosition;
 import jadx.api.ICodeInfo;
 import jadx.api.ICodeWriter;
 import jadx.api.JadxArgs;
-import jadx.api.data.annotations.InsnCodeOffset;
 import jadx.api.impl.AnnotatedCodeWriter;
 import jadx.api.impl.SimpleCodeWriter;
+import jadx.api.metadata.ICodeMetadata;
+import jadx.api.metadata.annotations.InsnCodeOffset;
 import jadx.core.codegen.ClassGen;
 import jadx.core.codegen.MethodGen;
 import jadx.core.codegen.json.cls.JsonClass;
@@ -180,24 +180,27 @@ public class JsonCodeGen {
 		}
 
 		String[] lines = codeStr.split(ICodeWriter.NL);
-		Map<Integer, Integer> lineMapping = code.getLineMapping();
+		Map<Integer, Integer> lineMapping = code.getCodeMetadata().getLineMapping();
-		Map<CodePosition, Object> annotations = code.getAnnotations();
+		ICodeMetadata metadata = code.getCodeMetadata();
 		long mthCodeOffset = mth.getMethodCodeOffset() + 16;
 
 		int linesCount = lines.length;
 		List<JsonCodeLine> codeLines = new ArrayList<>(linesCount);
+		int lineStartPos = 0;
+		int newLineLen = ICodeWriter.NL.length();
 		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));
+			Object obj = metadata.getAt(lineStartPos);
 			if (obj instanceof InsnCodeOffset) {
 				long offset = ((InsnCodeOffset) obj).getOffset();
 				jsonCodeLine.setOffset("0x" + Long.toHexString(mthCodeOffset + offset * 2));
 			}
 			codeLines.add(jsonCodeLine);
+			lineStartPos += codeLine.length() + newLineLen;
 		}
 		return codeLines;
 	}

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

@@ -80,6 +80,7 @@ public enum AFlag {
 	RERUN_SSA_TRANSFORM,
 
 	METHOD_CANDIDATE_FOR_INLINE,
+	USE_LINES_HINTS, // source lines info in methods can be trusted
 
 	DISABLE_BLOCKS_LOCK,
 

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

@@ -5,10 +5,6 @@ public interface ILineAttributeNode {
 
 	void setSourceLine(int sourceLine);
 
-	int getDecompiledLine();
-
-	void setDecompiledLine(int line);
-
 	int getDefPosition();
 
 	void setDefPosition(int pos);

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

@@ -7,21 +7,11 @@ public abstract class LineAttrNode extends AttrNode implements ILineAttributeNod
 
 	private int sourceLine;
 
-	private int decompiledLine;
+	/**
-
+	 * Position where a node declared at in decompiled code
-	// the position exactly where a node declared at in decompiled java code.
+	 */
 	private int defPosition;
 
-	@Override
-	public int getDefPosition() {
-		return this.defPosition;
-	}
-
-	@Override
-	public void setDefPosition(int defPosition) {
-		this.defPosition = defPosition;
-	}
-
 	@Override
 	public int getSourceLine() {
 		return sourceLine;
@@ -33,13 +23,13 @@ public abstract class LineAttrNode extends AttrNode implements ILineAttributeNod
 	}
 
 	@Override
-	public int getDecompiledLine() {
+	public int getDefPosition() {
-		return decompiledLine;
+		return this.defPosition;
 	}
 
 	@Override
-	public void setDecompiledLine(int decompiledLine) {
+	public void setDefPosition(int defPosition) {
-		this.decompiledLine = decompiledLine;
+		this.defPosition = defPosition;
 	}
 
 	public void addSourceLineFrom(LineAttrNode lineAttrNode) {
@@ -50,6 +40,6 @@ public abstract class LineAttrNode extends AttrNode implements ILineAttributeNod
 
 	public void copyLines(LineAttrNode lineAttrNode) {
 		setSourceLine(lineAttrNode.getSourceLine());
-		setDecompiledLine(lineAttrNode.getDecompiledLine());
+		setDefPosition(lineAttrNode.getDefPosition());
 	}
 }

jadx-core/src/main/java/jadx/core/dex/instructions/args/ArgType.java

@@ -12,9 +12,9 @@ import org.jetbrains.annotations.TestOnly;
 
 import jadx.core.Consts;
 import jadx.core.dex.info.ClassInfo;
-import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.RootNode;
 import jadx.core.dex.visitors.typeinference.TypeCompareEnum;
+import jadx.core.utils.ListUtils;
 import jadx.core.utils.Utils;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
@@ -874,28 +874,37 @@ public abstract class ArgType {
 	}
 
 	public static ArgType tryToResolveClassAlias(RootNode root, ArgType type) {
-		if (!type.isObject() || type.isGenericType()) {
+		if (type.isGenericType()) {
 			return type;
 		}
+		if (type.isArray()) {
+			ArgType rootType = type.getArrayRootElement();
+			ArgType aliasType = tryToResolveClassAlias(root, rootType);
+			if (aliasType == rootType) {
+				return type;
+			}
+			return ArgType.array(aliasType, type.getArrayDimension());
+		}
+		if (type.isObject()) {
+			ArgType wildcardType = type.getWildcardType();
+			if (wildcardType != null) {
+				return new WildcardType(tryToResolveClassAlias(root, wildcardType), type.getWildcardBound());
+			}
+			ClassInfo clsInfo = ClassInfo.fromName(root, type.getObject());
+			ArgType baseType = clsInfo.hasAlias() ? ArgType.object(clsInfo.getAliasFullName()) : type;
+			if (!type.isGeneric()) {
+				return baseType;
+			}
+			List<ArgType> genericTypes = type.getGenericTypes();
+			if (genericTypes != null) {
+				return new GenericObject(baseType.getObject(), tryToResolveClassAlias(root, genericTypes));
+			}
+		}
+		return type;
+	}
 
-		ClassNode cls = root.resolveClass(type);
+	public static List<ArgType> tryToResolveClassAlias(RootNode root, List<ArgType> types) {
-		if (cls == null) {
+		return ListUtils.map(types, t -> tryToResolveClassAlias(root, t));
-			return type;
-		}
-		ClassInfo clsInfo = cls.getClassInfo();
-		if (!clsInfo.hasAlias()) {
-			return type;
-		}
-		String aliasFullName = clsInfo.getAliasFullName();
-		if (type.isGeneric()) {
-			if (type instanceof GenericObject) {
-				return new GenericObject(aliasFullName, type.getGenericTypes());
-			}
-			if (type instanceof WildcardType) {
-				return new WildcardType(ArgType.object(aliasFullName), type.getWildcardBound());
-			}
-		}
-		return ArgType.object(aliasFullName);
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/instructions/args/CodeVar.java

@@ -4,7 +4,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import jadx.api.data.annotations.VarRef;
+import jadx.api.metadata.annotations.VarNode;
 
 public class CodeVar {
 	private String name;
@@ -15,7 +15,7 @@ public class CodeVar {
 	private boolean isThis;
 	private boolean isDeclared;
 
-	private VarRef cachedVarRef; // set and used at codegen stage
+	private VarNode cachedVarNode; // set and used at codegen stage
 
 	public static CodeVar fromMthArg(RegisterArg mthArg, boolean linkRegister) {
 		CodeVar var = new CodeVar();
@@ -94,12 +94,12 @@ public class CodeVar {
 		isDeclared = declared;
 	}
 
-	public VarRef getCachedVarRef() {
+	public VarNode getCachedVarNode() {
-		return cachedVarRef;
+		return cachedVarNode;
 	}
 
-	public void setCachedVarRef(VarRef cachedVarRef) {
+	public void setCachedVarNode(VarNode varNode) {
-		this.cachedVarRef = cachedVarRef;
+		this.cachedVarNode = varNode;
 	}
 
 	/**

jadx-core/src/main/java/jadx/core/dex/nodes/ClassNode.java

@@ -374,12 +374,14 @@ public class ClassNode extends NotificationAttrNode implements ILoadable, ICodeN
 		String clsRawName = getRawName();
 		if (searchInCache) {
 			ICodeInfo code = codeCache.get(clsRawName);
-			if (code != null && code != ICodeInfo.EMPTY) {
+			if (code != ICodeInfo.EMPTY) {
 				return code;
 			}
 		}
 		ICodeInfo codeInfo = root.getProcessClasses().generateCode(this);
-		codeCache.add(clsRawName, codeInfo);
+		if (codeInfo != ICodeInfo.EMPTY) {
+			codeCache.add(clsRawName, codeInfo);
+		}
 		return codeInfo;
 	}
 
@@ -817,6 +819,11 @@ public class ClassNode extends NotificationAttrNode implements ILoadable, ICodeN
 		return clsData == null ? "synthetic" : clsData.getInputFileName();
 	}
 
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.CLASS;
+	}
+
 	@Override
 	public int hashCode() {
 		return clsInfo.hashCode();

jadx-core/src/main/java/jadx/core/dex/nodes/FieldNode.java

@@ -100,6 +100,11 @@ public class FieldNode extends NotificationAttrNode implements ICodeNode {
 		return parentClass.root();
 	}
 
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.FIELD;
+	}
+
 	@Override
 	public int hashCode() {
 		return fieldInfo.hashCode();

jadx-core/src/main/java/jadx/core/dex/nodes/ICodeNode.java

@@ -1,9 +1,10 @@
 package jadx.core.dex.nodes;
 
+import jadx.api.metadata.ICodeNodeRef;
 import jadx.core.dex.attributes.IAttributeNode;
 import jadx.core.dex.info.AccessInfo;
 
-public interface ICodeNode extends IDexNode, IAttributeNode, IUsageInfoNode {
+public interface ICodeNode extends IDexNode, IAttributeNode, IUsageInfoNode, ICodeNodeRef {
 	AccessInfo getAccessFlags();
 
 	void setAccessFlags(AccessInfo newAccessFlags);

jadx-core/src/main/java/jadx/core/dex/nodes/MethodNode.java

@@ -592,6 +592,11 @@ public class MethodNode extends NotificationAttrNode implements IMethodDetails,
 		this.useIn = useIn;
 	}
 
+	@Override
+	public AnnType getAnnType() {
+		return AnnType.METHOD;
+	}
+
 	@Override
 	public int hashCode() {
 		return mthInfo.hashCode();

jadx-core/src/main/java/jadx/core/dex/nodes/RootNode.java

@@ -115,21 +115,25 @@ public class RootNode {
 	}
 
 	private void addDummyClass(IClassData classData, Exception exc) {
-		String typeStr = classData.getType();
-		String name = null;
 		try {
-			ClassInfo clsInfo = ClassInfo.fromName(this, typeStr);
+			String typeStr = classData.getType();
-			if (clsInfo != null) {
+			String name = null;
-				name = clsInfo.getShortName();
+			try {
+				ClassInfo clsInfo = ClassInfo.fromName(this, typeStr);
+				if (clsInfo != null) {
+					name = clsInfo.getShortName();
+				}
+			} catch (Exception e) {
+				LOG.error("Failed to get name for class with type {}", typeStr, e);
 			}
-		} catch (Exception e) {
+			if (name == null || name.isEmpty()) {
-			LOG.error("Failed to get name for class with type {}", typeStr, e);
+				name = "CLASS_" + typeStr;
+			}
+			ClassNode clsNode = ClassNode.addSyntheticClass(this, name, classData.getAccessFlags());
+			ErrorsCounter.error(clsNode, "Load error", exc);
+		} catch (Exception innerExc) {
+			LOG.error("Failed to load class from file: {}", classData.getInputFileName(), exc);
 		}
-		if (name == null || name.isEmpty()) {
-			name = "CLASS_" + typeStr;
-		}
-		ClassNode clsNode = ClassNode.addSyntheticClass(this, name, classData.getAccessFlags());
-		ErrorsCounter.error(clsNode, "Load error", exc);
 	}
 
 	private static void markDuplicatedClasses(List<ClassNode> classes) {

jadx-core/src/main/java/jadx/core/dex/nodes/utils/MethodUtils.java

@@ -45,6 +45,15 @@ public class MethodUtils {
 		return root.getClsp().getMethodDetails(callMth);
 	}
 
+	@Nullable
+	public MethodNode resolveMethod(BaseInvokeNode invokeNode) {
+		IMethodDetails methodDetails = getMethodDetails(invokeNode);
+		if (methodDetails instanceof MethodNode) {
+			return ((MethodNode) methodDetails);
+		}
+		return null;
+	}
+
 	/**
 	 * Search methods with same name and args count in class hierarchy starting from {@code startCls}
 	 * Beware {@code startCls} can be different from {@code mthInfo.getDeclClass()}

jadx-core/src/main/java/jadx/core/dex/regions/conditions/IfCondition.java

@@ -278,6 +278,16 @@ public final class IfCondition extends AttrNode {
 		return list;
 	}
 
+	public int getSourceLine() {
+		for (InsnNode insn : collectInsns()) {
+			int line = insn.getSourceLine();
+			if (line != 0) {
+				return line;
+			}
+		}
+		return 0;
+	}
+
 	@Nullable
 	public InsnNode getFirstInsn() {
 		if (mode == Mode.COMPARE) {

jadx-core/src/main/java/jadx/core/dex/visitors/MoveInlineVisitor.java

@@ -61,7 +61,9 @@ public class MoveInlineVisitor extends AbstractVisitor {
 		}
 		SSAVar ssaVar = resultArg.getSVar();
 		if (ssaVar.isUsedInPhi()) {
-			return deleteMove(mth, move);
+			return false;
+			// TODO: review conditions of 'up' move inline (test TestMoveInline)
+			// return deleteMove(mth, move);
 		}
 		RegDebugInfoAttr debugInfo = moveArg.get(AType.REG_DEBUG_INFO);
 		for (RegisterArg useArg : ssaVar.getUseList()) {

jadx-core/src/main/java/jadx/core/dex/visitors/debuginfo/DebugInfoAttachVisitor.java

@@ -1,12 +1,15 @@
 package jadx.core.dex.visitors.debuginfo;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import jadx.api.plugins.input.data.IDebugInfo;
 import jadx.api.plugins.input.data.ILocalVar;
+import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.nodes.LocalVarsDebugInfoAttr;
 import jadx.core.dex.attributes.nodes.RegDebugInfoAttr;
+import jadx.core.dex.instructions.InsnType;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.InsnArg;
 import jadx.core.dex.instructions.args.RegisterArg;
@@ -17,6 +20,7 @@ import jadx.core.dex.visitors.AbstractVisitor;
 import jadx.core.dex.visitors.JadxVisitor;
 import jadx.core.dex.visitors.blocks.BlockSplitter;
 import jadx.core.dex.visitors.ssa.SSATransform;
+import jadx.core.utils.ListUtils;
 import jadx.core.utils.exceptions.JadxException;
 
 @JadxVisitor(
@@ -52,17 +56,30 @@ public class DebugInfoAttachVisitor extends AbstractVisitor {
 		if (lineMapping.isEmpty()) {
 			return;
 		}
+		Map<Integer, Integer> linesStat = new HashMap<>(); // count repeating lines
 		for (Map.Entry<Integer, Integer> entry : lineMapping.entrySet()) {
 			try {
 				Integer offset = entry.getKey();
 				InsnNode insn = insnArr[offset];
 				if (insn != null) {
-					insn.setSourceLine(entry.getValue());
+					int line = entry.getValue();
+					insn.setSourceLine(line);
+					if (insn.getType() != InsnType.NOP) {
+						linesStat.merge(line, 1, (v, one) -> v + 1);
+					}
 				}
 			} catch (Exception e) {
 				mth.addWarnComment("Error attach source line", e);
 			}
 		}
+		// 3 here is allowed maximum for lines repeat,
+		// can occur in indexed 'for' loops (3 instructions with same line)
+		List<Map.Entry<Integer, Integer>> repeatingLines = ListUtils.filter(linesStat.entrySet(), p -> p.getValue() > 3);
+		if (repeatingLines.isEmpty()) {
+			mth.add(AFlag.USE_LINES_HINTS);
+		} else {
+			mth.addDebugComment("Don't trust debug lines info. Repeating lines: " + repeatingLines);
+		}
 	}
 
 	private void attachDebugInfo(MethodNode mth, List<ILocalVar> localVars, InsnNode[] insnArr) {

jadx-core/src/main/java/jadx/core/dex/visitors/regions/IfRegionVisitor.java

@@ -38,15 +38,105 @@ public class IfRegionVisitor extends AbstractVisitor {
 		public boolean enterRegion(MethodNode mth, IRegion region) {
 			if (region instanceof IfRegion) {
 				IfRegion ifRegion = (IfRegion) region;
-				simplifyIfCondition(ifRegion);
+				orderBranches(mth, ifRegion);
-				moveReturnToThenBlock(mth, ifRegion);
+				markElseIfChains(mth, ifRegion);
-				moveBreakToThenBlock(ifRegion);
-				markElseIfChains(ifRegion);
 			}
 			return true;
 		}
 	}
 
+	@SuppressWarnings("UnnecessaryReturnStatement")
+	private static void orderBranches(MethodNode mth, IfRegion ifRegion) {
+		if (RegionUtils.isEmpty(ifRegion.getElseRegion())) {
+			return;
+		}
+		if (RegionUtils.isEmpty(ifRegion.getThenRegion())) {
+			invertIfRegion(ifRegion);
+			return;
+		}
+		if (mth.contains(AFlag.USE_LINES_HINTS)) {
+			int thenLine = RegionUtils.getFirstSourceLine(ifRegion.getThenRegion());
+			int elseLine = RegionUtils.getFirstSourceLine(ifRegion.getElseRegion());
+			if (thenLine != 0 && elseLine != 0) {
+				if (thenLine > elseLine) {
+					invertIfRegion(ifRegion);
+				}
+				return;
+			}
+		}
+		if (ifRegion.simplifyCondition()) {
+			IfCondition condition = ifRegion.getCondition();
+			if (condition != null && condition.getMode() == Mode.NOT) {
+				invertIfRegion(ifRegion);
+			}
+		}
+		int thenSize = insnsCount(ifRegion.getThenRegion());
+		int elseSize = insnsCount(ifRegion.getElseRegion());
+		if (isSimpleExitBlock(mth, ifRegion.getElseRegion())) {
+			if (isSimpleExitBlock(mth, ifRegion.getThenRegion())) {
+				if (elseSize < thenSize) {
+					invertIfRegion(ifRegion);
+					return;
+				}
+			}
+			boolean lastRegion = ifRegion == RegionUtils.getLastRegion(mth.getRegion());
+			if (elseSize == 1 && lastRegion && mth.isVoidReturn()) {
+				// single return at method end will be removed later
+				return;
+			}
+			if (!lastRegion) {
+				invertIfRegion(ifRegion);
+			}
+			return;
+		}
+		boolean thenExit = RegionUtils.hasExitBlock(ifRegion.getThenRegion());
+		boolean elseExit = RegionUtils.hasExitBlock(ifRegion.getElseRegion());
+		if (elseExit && (!thenExit || elseSize < thenSize)) {
+			invertIfRegion(ifRegion);
+			return;
+		}
+		// move 'if' from 'then' branch to make 'else if' chain
+		if (isIfRegion(ifRegion.getThenRegion())
+				&& !isIfRegion(ifRegion.getElseRegion())
+				&& !thenExit) {
+			invertIfRegion(ifRegion);
+			return;
+		}
+		// move 'break' into 'then' branch
+		if (RegionUtils.hasBreakInsn(ifRegion.getElseRegion())) {
+			invertIfRegion(ifRegion);
+			return;
+		}
+	}
+
+	private static boolean isIfRegion(IContainer container) {
+		if (container instanceof IfRegion) {
+			return true;
+		}
+		if (container instanceof IRegion) {
+			List<IContainer> subBlocks = ((IRegion) container).getSubBlocks();
+			return subBlocks.size() == 1 && subBlocks.get(0) instanceof IfRegion;
+		}
+		return false;
+	}
+
+	/**
+	 * Mark if-else-if chains
+	 */
+	private static void markElseIfChains(MethodNode mth, IfRegion ifRegion) {
+		if (isSimpleExitBlock(mth, ifRegion.getThenRegion())) {
+			return;
+		}
+		IContainer elsRegion = ifRegion.getElseRegion();
+		if (elsRegion instanceof Region) {
+			List<IContainer> subBlocks = ((Region) elsRegion).getSubBlocks();
+			if (subBlocks.size() == 1 && subBlocks.get(0) instanceof IfRegion) {
+				subBlocks.get(0).add(AFlag.ELSE_IF_CHAIN);
+				elsRegion.add(AFlag.ELSE_IF_CHAIN);
+			}
+		}
+	}
+
 	private static class RemoveRedundantElseVisitor implements IRegionIterativeVisitor {
 		@Override
 		public boolean visitRegion(MethodNode mth, IRegion region) {
@@ -57,76 +147,6 @@ public class IfRegionVisitor extends AbstractVisitor {
 		}
 	}
 
-	private static void simplifyIfCondition(IfRegion ifRegion) {
-		if (ifRegion.simplifyCondition()) {
-			IfCondition condition = ifRegion.getCondition();
-			if (condition.getMode() == Mode.NOT) {
-				invertIfRegion(ifRegion);
-			}
-		}
-		IContainer elseRegion = ifRegion.getElseRegion();
-		if (elseRegion == null || RegionUtils.isEmpty(elseRegion)) {
-			return;
-		}
-		boolean thenIsEmpty = RegionUtils.isEmpty(ifRegion.getThenRegion());
-		if (thenIsEmpty || hasSimpleReturnBlock(ifRegion.getThenRegion())) {
-			invertIfRegion(ifRegion);
-		}
-
-		if (!thenIsEmpty) {
-			// move 'if' from then to make 'else if' chain
-			if (isIfRegion(ifRegion.getThenRegion())
-					&& !isIfRegion(elseRegion)) {
-				invertIfRegion(ifRegion);
-			}
-		}
-	}
-
-	private static boolean isIfRegion(IContainer container) {
-		if (container instanceof IfRegion) {
-			return true;
-		}
-		if (container instanceof IRegion) {
-			List<IContainer> subBlocks = ((IRegion) container).getSubBlocks();
-			if (subBlocks.size() == 1 && subBlocks.get(0) instanceof IfRegion) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private static void moveReturnToThenBlock(MethodNode mth, IfRegion ifRegion) {
-		if (!mth.isVoidReturn()
-				&& hasSimpleReturnBlock(ifRegion.getElseRegion())
-		/* && insnsCount(ifRegion.getThenRegion()) < 2 */) {
-			invertIfRegion(ifRegion);
-		}
-	}
-
-	private static void moveBreakToThenBlock(IfRegion ifRegion) {
-		if (ifRegion.getElseRegion() != null
-				&& RegionUtils.hasBreakInsn(ifRegion.getElseRegion())) {
-			invertIfRegion(ifRegion);
-		}
-	}
-
-	/**
-	 * Mark if-else-if chains
-	 */
-	private static void markElseIfChains(IfRegion ifRegion) {
-		if (hasSimpleReturnBlock(ifRegion.getThenRegion())) {
-			return;
-		}
-		IContainer elsRegion = ifRegion.getElseRegion();
-		if (elsRegion instanceof Region) {
-			List<IContainer> subBlocks = ((Region) elsRegion).getSubBlocks();
-			if (subBlocks.size() == 1 && subBlocks.get(0) instanceof IfRegion) {
-				subBlocks.get(0).add(AFlag.ELSE_IF_CHAIN);
-				elsRegion.add(AFlag.ELSE_IF_CHAIN);
-			}
-		}
-	}
-
 	private static boolean removeRedundantElseBlock(MethodNode mth, IfRegion ifRegion) {
 		if (ifRegion.getElseRegion() == null
 				|| ifRegion.contains(AFlag.ELSE_IF_CHAIN)
@@ -162,16 +182,16 @@ public class IfRegionVisitor extends AbstractVisitor {
 		}
 	}
 
-	private static boolean hasSimpleReturnBlock(IContainer region) {
+	private static boolean isSimpleExitBlock(MethodNode mth, IContainer container) {
-		if (region == null) {
+		if (container == null) {
 			return false;
 		}
-		if (region.contains(AFlag.RETURN)) {
+		if (container.contains(AFlag.RETURN) || RegionUtils.isExitBlock(mth, container)) {
 			return true;
 		}
-		if (region instanceof IRegion) {
+		if (container instanceof IRegion) {
-			List<IContainer> subBlocks = ((IRegion) region).getSubBlocks();
+			List<IContainer> subBlocks = ((IRegion) container).getSubBlocks();
-			return subBlocks.size() == 1 && subBlocks.get(0).contains(AFlag.RETURN);
+			return subBlocks.size() == 1 && RegionUtils.isExitBlock(mth, subBlocks.get(0));
 		}
 		return false;
 	}

jadx-core/src/main/java/jadx/core/dex/visitors/regions/TernaryMod.java

@@ -93,7 +93,8 @@ public class TernaryMod extends AbstractRegionVisitor implements IRegionIterativ
 		InsnNode thenInsn = tb.getInstructions().get(0);
 		InsnNode elseInsn = eb.getInstructions().get(0);
 
-		if (thenInsn.getSourceLine() != elseInsn.getSourceLine()) {
+		if (mth.contains(AFlag.USE_LINES_HINTS)
+				&& thenInsn.getSourceLine() != elseInsn.getSourceLine()) {
 			if (thenInsn.getSourceLine() != 0 && elseInsn.getSourceLine() != 0) {
 				// sometimes source lines incorrect
 				if (!checkLineStats(thenInsn, elseInsn)) {
@@ -134,6 +135,8 @@ public class TernaryMod extends AbstractRegionVisitor implements IRegionIterativ
 			InsnArg thenArg = InsnArg.wrapInsnIntoArg(thenInsn);
 			InsnArg elseArg = InsnArg.wrapInsnIntoArg(elseInsn);
 			TernaryInsn ternInsn = new TernaryInsn(ifRegion.getCondition(), resArg, thenArg, elseArg);
+			int branchLine = Math.max(thenInsn.getSourceLine(), elseInsn.getSourceLine());
+			ternInsn.setSourceLine(Math.max(ifRegion.getSourceLine(), branchLine));
 
 			InsnRemover.unbindResult(mth, elseInsn);
 

jadx-core/src/main/java/jadx/core/utils/BlockUtils.java

@@ -182,6 +182,16 @@ public class BlockUtils {
 		return null;
 	}
 
+	public static int getFirstSourceLine(IBlock block) {
+		for (InsnNode insn : block.getInstructions()) {
+			int line = insn.getSourceLine();
+			if (line != 0) {
+				return line;
+			}
+		}
+		return 0;
+	}
+
 	@Nullable
 	public static InsnNode getFirstInsn(@Nullable IBlock block) {
 		if (block == null) {
@@ -207,11 +217,22 @@ public class BlockUtils {
 	}
 
 	public static boolean isExitBlock(MethodNode mth, BlockNode block) {
-		BlockNode exitBlock = mth.getExitBlock();
+		if (block == mth.getExitBlock()) {
-		if (block == exitBlock) {
 			return true;
 		}
-		return exitBlock.getPredecessors().contains(block);
+		return isExitBlock(block);
+	}
+
+	public static boolean isExitBlock(BlockNode block) {
+		List<BlockNode> successors = block.getSuccessors();
+		if (successors.isEmpty()) {
+			return true;
+		}
+		if (successors.size() == 1) {
+			BlockNode next = successors.get(0);
+			return next.getSuccessors().isEmpty();
+		}
+		return false;
 	}
 
 	public static boolean containsExitInsn(IBlock block) {

jadx-core/src/main/java/jadx/core/utils/CodeGenUtils.java

@@ -4,9 +4,9 @@ import java.util.List;
 
 import org.jetbrains.annotations.Nullable;
 
-import jadx.api.CodePosition;
 import jadx.api.CommentsLevel;
 import jadx.api.ICodeWriter;
+import jadx.api.metadata.ICodeAnnotation;
 import jadx.api.plugins.input.data.attributes.JadxAttrType;
 import jadx.api.plugins.input.data.attributes.types.SourceFileAttr;
 import jadx.core.dex.attributes.AType;
@@ -95,7 +95,7 @@ public class CodeGenUtils {
 	private static void addMultiLineComment(ICodeWriter code, List<String> comments) {
 		boolean first = true;
 		String indent = "";
-		Object lineAnn = null;
+		ICodeAnnotation lineAnn = null;
 		for (String comment : comments) {
 			for (String line : comment.split("\n")) {
 				if (first) {
@@ -104,7 +104,7 @@ public class CodeGenUtils {
 					int startLinePos = buf.lastIndexOf(ICodeWriter.NL) + 1;
 					indent = Utils.strRepeat(" ", buf.length() - startLinePos);
 					if (code.isMetadataSupported()) {
-						lineAnn = code.getRawAnnotations().get(new CodePosition(code.getLine()));
+						lineAnn = code.getRawAnnotations().get(startLinePos);
 					}
 				} else {
 					code.newLine().add(indent);

jadx-core/src/main/java/jadx/core/utils/DecompilerScheduler.java

@@ -13,9 +13,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import jadx.api.IDecompileScheduler;
-import jadx.api.JadxDecompiler;
 import jadx.api.JavaClass;
-import jadx.core.dex.nodes.ClassNode;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
 public class DecompilerScheduler implements IDecompileScheduler {
@@ -24,18 +22,11 @@ public class DecompilerScheduler implements IDecompileScheduler {
 	private static final int MERGED_BATCH_SIZE = 16;
 	private static final boolean DEBUG_BATCHES = false;
 
-	private final JadxDecompiler decompiler;
-
-	public DecompilerScheduler(JadxDecompiler decompiler) {
-		this.decompiler = decompiler;
-	}
-
 	@Override
 	public List<List<JavaClass>> buildBatches(List<JavaClass> classes) {
 		try {
 			long start = System.currentTimeMillis();
-			List<List<ClassNode>> batches = internalBatches(Utils.collectionMap(classes, JavaClass::getClassNode));
+			List<List<JavaClass>> result = internalBatches(classes);
-			List<List<JavaClass>> result = Utils.collectionMap(batches, l -> Utils.collectionMapNoNull(l, decompiler::getJavaClassByNode));
 			if (LOG.isDebugEnabled()) {
 				LOG.debug("Build decompilation batches in {}ms", System.currentTimeMillis() - start);
 			}
@@ -53,14 +44,14 @@ public class DecompilerScheduler implements IDecompileScheduler {
 	 * Put classes with many dependencies at the end.
 	 * Build batches for dependencies of single class to avoid locking from another thread.
 	 */
-	public List<List<ClassNode>> internalBatches(List<ClassNode> classes) {
+	public List<List<JavaClass>> internalBatches(List<JavaClass> classes) {
 		List<DepInfo> deps = sumDependencies(classes);
-		Set<ClassNode> added = new HashSet<>(classes.size());
+		Set<JavaClass> added = new HashSet<>(classes.size());
-		Comparator<ClassNode> cmpDepSize = Comparator.comparingInt(ClassNode::getTotalDepsCount);
+		Comparator<JavaClass> cmpDepSize = Comparator.comparingInt(JavaClass::getTotalDepsCount);
-		List<List<ClassNode>> result = new ArrayList<>();
+		List<List<JavaClass>> result = new ArrayList<>();
-		List<ClassNode> mergedBatch = new ArrayList<>(MERGED_BATCH_SIZE);
+		List<JavaClass> mergedBatch = new ArrayList<>(MERGED_BATCH_SIZE);
 		for (DepInfo depInfo : deps) {
-			ClassNode cls = depInfo.getCls();
+			JavaClass cls = depInfo.getCls();
 			if (!added.add(cls)) {
 				continue;
 			}
@@ -73,9 +64,9 @@ public class DecompilerScheduler implements IDecompileScheduler {
 					mergedBatch = new ArrayList<>(MERGED_BATCH_SIZE);
 				}
 			} else {
-				List<ClassNode> batch = new ArrayList<>(depsSize + 1);
+				List<JavaClass> batch = new ArrayList<>(depsSize + 1);
-				for (ClassNode dep : cls.getDependencies()) {
+				for (JavaClass dep : cls.getDependencies()) {
-					ClassNode topDep = dep.getTopParentClass();
+					JavaClass topDep = dep.getTopParentClass();
 					if (!added.contains(topDep)) {
 						batch.add(topDep);
 						added.add(topDep);
@@ -95,11 +86,11 @@ public class DecompilerScheduler implements IDecompileScheduler {
 		return result;
 	}
 
-	private static List<DepInfo> sumDependencies(List<ClassNode> classes) {
+	private static List<DepInfo> sumDependencies(List<JavaClass> classes) {
 		List<DepInfo> deps = new ArrayList<>(classes.size());
-		for (ClassNode cls : classes) {
+		for (JavaClass cls : classes) {
 			int count = 0;
-			for (ClassNode dep : cls.getDependencies()) {
+			for (JavaClass dep : cls.getDependencies()) {
 				count += 1 + dep.getTotalDepsCount();
 			}
 			deps.add(new DepInfo(cls, count));
@@ -109,15 +100,15 @@ public class DecompilerScheduler implements IDecompileScheduler {
 	}
 
 	private static final class DepInfo implements Comparable<DepInfo> {
-		private final ClassNode cls;
+		private final JavaClass cls;
 		private final int depsCount;
 
-		private DepInfo(ClassNode cls, int depsCount) {
+		private DepInfo(JavaClass cls, int depsCount) {
 			this.cls = cls;
 			this.depsCount = depsCount;
 		}
 
-		public ClassNode getCls() {
+		public JavaClass getCls() {
 			return cls;
 		}
 
@@ -129,7 +120,7 @@ public class DecompilerScheduler implements IDecompileScheduler {
 		public int compareTo(@NotNull DecompilerScheduler.DepInfo o) {
 			int deps = Integer.compare(depsCount, o.depsCount);
 			if (deps == 0) {
-				return cls.compareTo(o.cls);
+				return cls.getClassNode().compareTo(o.cls.getClassNode());
 			}
 			return deps;
 		}
@@ -147,9 +138,9 @@ public class DecompilerScheduler implements IDecompileScheduler {
 				.collect(Collectors.toList());
 	}
 
-	private void dumpBatchesStats(List<ClassNode> classes, List<List<ClassNode>> result, List<DepInfo> deps) {
+	private void dumpBatchesStats(List<JavaClass> classes, List<List<JavaClass>> result, List<DepInfo> deps) {
 		double avg = result.stream().mapToInt(List::size).average().orElse(-1);
-		int maxSingleDeps = classes.stream().mapToInt(ClassNode::getTotalDepsCount).max().orElse(-1);
+		int maxSingleDeps = classes.stream().mapToInt(JavaClass::getTotalDepsCount).max().orElse(-1);
 		int maxSubDeps = deps.stream().mapToInt(DepInfo::getDepsCount).max().orElse(-1);
 		LOG.info("Batches stats:"
 				+ "\n input classes: " + classes.size()

jadx-core/src/main/java/jadx/core/utils/RegionUtils.java

@@ -16,6 +16,7 @@ import jadx.core.dex.instructions.InsnType;
 import jadx.core.dex.nodes.BlockNode;
 import jadx.core.dex.nodes.IBlock;
 import jadx.core.dex.nodes.IBranchRegion;
+import jadx.core.dex.nodes.IConditionRegion;
 import jadx.core.dex.nodes.IContainer;
 import jadx.core.dex.nodes.IRegion;
 import jadx.core.dex.nodes.InsnNode;
@@ -52,6 +53,7 @@ public class RegionUtils {
 		throw new JadxRuntimeException(unknownContainerType(container));
 	}
 
+	@Nullable
 	public static InsnNode getFirstInsn(IContainer container) {
 		if (container instanceof IBlock) {
 			IBlock block = (IBlock) container;
@@ -74,6 +76,37 @@ public class RegionUtils {
 		}
 	}
 
+	public static int getFirstSourceLine(IContainer container) {
+		if (container instanceof IBlock) {
+			return BlockUtils.getFirstSourceLine((IBlock) container);
+		}
+		if (container instanceof IConditionRegion) {
+			return ((IConditionRegion) container).getConditionSourceLine();
+		}
+		if (container instanceof IBranchRegion) {
+			IBranchRegion branchRegion = (IBranchRegion) container;
+			return getFirstSourceLine(branchRegion.getBranches());
+		}
+		if (container instanceof IRegion) {
+			IRegion region = (IRegion) container;
+			return getFirstSourceLine(region.getSubBlocks());
+		}
+		return 0;
+	}
+
+	private static int getFirstSourceLine(List<IContainer> containers) {
+		if (containers.isEmpty()) {
+			return 0;
+		}
+		for (IContainer container : containers) {
+			int line = getFirstSourceLine(container);
+			if (line != 0) {
+				return line;
+			}
+		}
+		return 0;
+	}
+
 	public static InsnNode getLastInsn(IContainer container) {
 		if (container instanceof IBlock) {
 			IBlock block = (IBlock) container;
@@ -112,31 +145,58 @@ public class RegionUtils {
 		}
 	}
 
+	@Nullable
+	public static IContainer getLastRegion(@Nullable IContainer container) {
+		if (container == null) {
+			return null;
+		}
+		if (container instanceof IBlock || container instanceof IBranchRegion) {
+			return container;
+		}
+		if (container instanceof IRegion) {
+			return getLastRegion(Utils.last(((IRegion) container).getSubBlocks()));
+		}
+		throw new JadxRuntimeException(unknownContainerType(container));
+	}
+
+	public static boolean isExitBlock(MethodNode mth, IContainer container) {
+		if (container instanceof BlockNode) {
+			return BlockUtils.isExitBlock(mth, (BlockNode) container);
+		}
+		return false;
+	}
+
 	/**
 	 * Return true if last block in region has no successors or jump out insn (return or break)
 	 */
 	public static boolean hasExitBlock(IContainer container) {
+		if (container == null) {
+			return false;
+		}
 		return hasExitBlock(container, container);
 	}
 
 	private static boolean hasExitBlock(IContainer rootContainer, IContainer container) {
 		if (container instanceof BlockNode) {
 			BlockNode blockNode = (BlockNode) container;
-			if (blockNode.getSuccessors().isEmpty()) {
+			if (BlockUtils.isExitBlock(blockNode)) {
 				return true;
 			}
 			return isInsnExitContainer(rootContainer, (IBlock) container);
-		} else if (container instanceof IBranchRegion) {
+		}
-			return false;
+		if (container instanceof IBranchRegion) {
-		} else if (container instanceof IBlock) {
+			IBranchRegion branchRegion = (IBranchRegion) container;
+			return ListUtils.allMatch(branchRegion.getBranches(), RegionUtils::hasExitBlock);
+		}
+		if (container instanceof IBlock) {
 			return isInsnExitContainer(rootContainer, (IBlock) container);
-		} else if (container instanceof IRegion) {
+		}
+		if (container instanceof IRegion) {
 			List<IContainer> blocks = ((IRegion) container).getSubBlocks();
 			return !blocks.isEmpty()
 					&& hasExitBlock(rootContainer, blocks.get(blocks.size() - 1));
-		} else {
-			throw new JadxRuntimeException(unknownContainerType(container));
 		}
+		throw new JadxRuntimeException(unknownContainerType(container));
 	}
 
 	private static boolean isInsnExitContainer(IContainer rootContainer, IBlock block) {
@@ -192,17 +252,25 @@ public class RegionUtils {
 
 	public static int insnsCount(IContainer container) {
 		if (container instanceof IBlock) {
-			return ((IBlock) container).getInstructions().size();
+			List<InsnNode> insnList = ((IBlock) container).getInstructions();
-		} else if (container instanceof IRegion) {
+			int count = 0;
+			for (InsnNode insn : insnList) {
+				if (insn.contains(AFlag.DONT_GENERATE)) {
+					continue;
+				}
+				count++;
+			}
+			return count;
+		}
+		if (container instanceof IRegion) {
 			IRegion region = (IRegion) container;
 			int count = 0;
 			for (IContainer block : region.getSubBlocks()) {
 				count += insnsCount(block);
 			}
 			return count;
-		} else {
-			throw new JadxRuntimeException(unknownContainerType(container));
 		}
+		throw new JadxRuntimeException(unknownContainerType(container));
 	}
 
 	public static boolean isEmpty(IContainer container) {

jadx-core/src/main/java/jadx/core/utils/files/FileUtils.java

@@ -8,16 +8,19 @@ import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.FileVisitOption;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.security.MessageDigest;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
 import java.util.jar.JarEntry;
 import java.util.jar.JarOutputStream;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.jetbrains.annotations.NotNull;
@@ -100,6 +103,10 @@ public class FileUtils {
 		}
 	}
 
+	public static void deleteFileIfExists(Path filePath) throws IOException {
+		Files.deleteIfExists(filePath);
+	}
+
 	public static boolean deleteDir(File dir) {
 		File[] content = dir.listFiles();
 		if (content != null) {
@@ -110,13 +117,24 @@ public class FileUtils {
 		return dir.delete();
 	}
 
-	public static void deleteDir(Path dir) {
+	public static void deleteDirIfExists(Path dir) {
+		if (Files.exists(dir)) {
+			try {
+				deleteDir(dir);
+			} catch (Exception e) {
+				LOG.error("Failed to delete dir: " + dir.toAbsolutePath(), e);
+			}
+		}
+	}
+
+	private static void deleteDir(Path dir) {
 		try (Stream<Path> pathStream = Files.walk(dir)) {
 			pathStream.sorted(Comparator.reverseOrder())
-					.map(Path::toFile)
+					.forEach(path -> {
-					.forEach(file -> {
+						try {
-						if (!file.delete()) {
+							Files.delete(path);
-							LOG.warn("Failed to remove file: {}", file.getAbsolutePath());
+						} catch (Exception e) {
+							throw new JadxRuntimeException("Failed to delete path: " + path.toAbsolutePath(), e);
 						}
 					});
 		} catch (Exception e) {
@@ -143,11 +161,11 @@ public class FileUtils {
 	}
 
 	public static void deleteTempRootDir() {
-		deleteDir(TEMP_ROOT_DIR);
+		deleteDirIfExists(TEMP_ROOT_DIR);
 	}
 
 	public static void clearTempRootDir() {
-		deleteDir(TEMP_ROOT_DIR);
+		deleteDirIfExists(TEMP_ROOT_DIR);
 		makeDirs(TEMP_ROOT_DIR);
 	}
 
@@ -208,6 +226,15 @@ public class FileUtils {
 		}
 	}
 
+	public static void writeFile(Path file, String data) throws IOException {
+		FileUtils.makeDirsForFile(file);
+		Files.write(file, data.getBytes(StandardCharsets.UTF_8));
+	}
+
+	public static String readFile(Path textFile) throws IOException {
+		return new String(Files.readAllBytes(textFile), StandardCharsets.UTF_8);
+	}
+
 	@NotNull
 	public static File prepareFile(File file) {
 		File saveFile = cutFileName(file);
@@ -230,18 +257,41 @@ public class FileUtils {
 		return new File(file.getParentFile(), name);
 	}
 
-	private static String bytesToHex(byte[] bytes) {
+	private static final byte[] HEX_ARRAY = "0123456789abcdef".getBytes(StandardCharsets.US_ASCII);
-		char[] hexArray = "0123456789abcdef".toCharArray();
+
-		if (bytes == null || bytes.length <= 0) {
+	public static String bytesToHex(byte[] bytes) {
-			return null;
+		if (bytes == null || bytes.length == 0) {
+			return "";
 		}
-		char[] hexChars = new char[bytes.length * 2];
+		byte[] hexChars = new byte[bytes.length * 2];
 		for (int j = 0; j < bytes.length; j++) {
 			int v = bytes[j] & 0xFF;
-			hexChars[j * 2] = hexArray[v >>> 4];
+			hexChars[j * 2] = HEX_ARRAY[v >>> 4];
-			hexChars[j * 2 + 1] = hexArray[v & 0x0F];
+			hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
 		}
-		return new String(hexChars);
+		return new String(hexChars, StandardCharsets.UTF_8);
+	}
+
+	/**
+	 * Zero padded hex string for first byte
+	 */
+	public static String byteToHex(int value) {
+		int v = value & 0xFF;
+		byte[] hexChars = new byte[] { HEX_ARRAY[v >>> 4], HEX_ARRAY[v & 0x0F] };
+		return new String(hexChars, StandardCharsets.US_ASCII);
+	}
+
+	/**
+	 * Zero padded hex string for int value
+	 */
+	public static String intToHex(int value) {
+		byte[] hexChars = new byte[8];
+		int v = value;
+		for (int i = 7; i >= 0; i--) {
+			hexChars[i] = HEX_ARRAY[v & 0x0F];
+			v >>>= 4;
+		}
+		return new String(hexChars, StandardCharsets.US_ASCII);
 	}
 
 	public static boolean isZipFile(File file) {
@@ -275,4 +325,30 @@ public class FileUtils {
 		}
 		return new File(path);
 	}
+
+	public static List<Path> toPaths(List<File> files) {
+		return files.stream().map(File::toPath).collect(Collectors.toList());
+	}
+
+	public static List<Path> toPaths(File[] files) {
+		return Stream.of(files).map(File::toPath).collect(Collectors.toList());
+	}
+
+	public static List<Path> fileNamesToPaths(List<String> fileNames) {
+		return fileNames.stream().map(Paths::get).collect(Collectors.toList());
+	}
+
+	public static List<File> toFiles(List<Path> paths) {
+		return paths.stream().map(Path::toFile).collect(Collectors.toList());
+	}
+
+	public static String md5Sum(byte[] data) {
+		try {
+			MessageDigest md = MessageDigest.getInstance("MD5");
+			md.update(data);
+			return bytesToHex(md.digest());
+		} catch (Exception e) {
+			throw new JadxRuntimeException("Failed to build hash", e);
+		}
+	}
 }

jadx-core/src/main/java/jadx/core/xmlgen/BinaryXMLParser.java

@@ -89,7 +89,8 @@ public class BinaryXMLParser extends CommonBinaryParser {
 		is.mark(4);
 		int v = is.readInt16(); // version
 		int h = is.readInt16(); // header size
-		if (v == 0x0003 && h == 0x0008) {
+		// Some APK Manifest.xml the version is 0
+		if (h == 0x0008) {
 			return true;
 		}
 		is.reset();

jadx-core/src/test/java/jadx/api/JadxArgsValidatorOutDirsTest.java

@@ -57,7 +57,7 @@ public class JadxArgsValidatorOutDirsTest {
 	}
 
 	private void checkOutDirs(String outDir, String srcDir, String resDir) {
-		JadxArgsValidator.validate(args);
+		JadxArgsValidator.validate(new JadxDecompiler(args));
 		LOG.debug("Got dirs: out={}, src={}, res={}", args.getOutDir(), args.getOutDirSrc(), args.getOutDirRes());
 		assertThat(args.getOutDir(), is(toFile(outDir)));
 		assertThat(args.getOutDirSrc(), is(toFile(srcDir)));

jadx-core/src/test/java/jadx/api/JadxDecompilerTest.java

@@ -1,12 +1,16 @@
 package jadx.api;
 
 import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.URL;
 
 import org.hamcrest.Matchers;
 import org.junit.jupiter.api.Test;
 
 import jadx.core.utils.files.FileUtils;
+import jadx.plugins.input.dex.DexInputPlugin;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.notNullValue;
@@ -38,6 +42,20 @@ public class JadxDecompilerTest {
 		}
 	}
 
+	@Test
+	public void testDirectDexInput() throws IOException {
+		try (JadxDecompiler jadx = new JadxDecompiler();
+				InputStream in = new FileInputStream(getFileFromSampleDir("hello.dex"))) {
+			jadx.addCustomLoad(new DexInputPlugin().loadDexFromInputStream(in, "input"));
+			jadx.load();
+			for (JavaClass cls : jadx.getClasses()) {
+				System.out.println(cls.getCode());
+			}
+			assertThat(jadx.getClasses(), Matchers.hasSize(1));
+			assertThat(jadx.getErrorsCount(), Matchers.is(0));
+		}
+	}
+
 	private static final String TEST_SAMPLES_DIR = "test-samples/";
 
 	public static File getFileFromSampleDir(String fileName) {

jadx-core/src/test/java/jadx/api/JadxInternalAccess.java

@@ -1,5 +1,8 @@
 package jadx.api;
 
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
 import jadx.core.dex.nodes.RootNode;
 
 public class JadxInternalAccess {
@@ -7,4 +10,16 @@ public class JadxInternalAccess {
 	public static RootNode getRoot(JadxDecompiler d) {
 		return d.getRoot();
 	}
+
+	public static JavaClass convertClassNode(JadxDecompiler d, ClassNode clsNode) {
+		return d.convertClassNode(clsNode);
+	}
+
+	public static JavaMethod convertMethodNode(JadxDecompiler d, MethodNode mthNode) {
+		return d.convertMethodNode(mthNode);
+	}
+
+	public static JavaField convertFieldNode(JadxDecompiler d, FieldNode fldNode) {
+		return d.convertFieldNode(fldNode);
+	}
 }

jadx-core/src/test/java/jadx/tests/api/IntegrationTest.java

@@ -32,7 +32,6 @@ import org.junit.jupiter.api.BeforeEach;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import jadx.api.CodePosition;
 import jadx.api.CommentsLevel;
 import jadx.api.ICodeInfo;
 import jadx.api.ICodeWriter;
@@ -41,7 +40,8 @@ import jadx.api.JadxDecompiler;
 import jadx.api.JadxInternalAccess;
 import jadx.api.JavaClass;
 import jadx.api.args.DeobfuscationMapFileMode;
-import jadx.api.data.annotations.InsnCodeOffset;
+import jadx.api.metadata.ICodeMetadata;
+import jadx.api.metadata.annotations.InsnCodeOffset;
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttributeNode;
@@ -150,9 +150,9 @@ public abstract class IntegrationTest extends TestUtils {
 		close(decompiledCompiler);
 	}
 
-	private void close(Closeable cloaseble) throws IOException {
+	private void close(Closeable closeable) throws IOException {
-		if (cloaseble != null) {
+		if (closeable != null) {
-			cloaseble.close();
+			closeable.close();
 		}
 	}
 
@@ -300,7 +300,7 @@ public abstract class IntegrationTest extends TestUtils {
 
 	private void printCodeWithLineNumbers(ICodeInfo code) {
 		String codeStr = code.getCodeStr();
-		Map<Integer, Integer> lineMapping = code.getLineMapping();
+		Map<Integer, Integer> lineMapping = code.getCodeMetadata().getLineMapping();
 		String[] lines = codeStr.split(ICodeWriter.NL);
 		for (int i = 0; i < lines.length; i++) {
 			String line = lines[i];
@@ -316,18 +316,18 @@ public abstract class IntegrationTest extends TestUtils {
 
 	private void printCodeWithOffsets(ICodeInfo code) {
 		String codeStr = code.getCodeStr();
-		Map<CodePosition, Object> annotations = code.getAnnotations();
+		ICodeMetadata metadata = code.getCodeMetadata();
-		String[] lines = codeStr.split(ICodeWriter.NL);
+		int lineStartPos = 0;
-		for (int i = 0; i < lines.length; i++) {
+		int newLineLen = ICodeWriter.NL.length();
-			String line = lines[i];
+		for (String line : codeStr.split(ICodeWriter.NL)) {
-			int curLine = i + 1;
+			Object ann = metadata.getAt(lineStartPos);
-			Object ann = annotations.get(new CodePosition(curLine, 0));
 			String offsetStr = "";
 			if (ann instanceof InsnCodeOffset) {
 				int offset = ((InsnCodeOffset) ann).getOffset();
 				offsetStr = "/* " + leftPad(String.valueOf(offset), 5) + " */";
 			}
 			System.out.println(rightPad(offsetStr, 12) + line);
+			lineStartPos += line.length() + newLineLen;
 		}
 	}
 

jadx-core/src/test/java/jadx/tests/api/utils/assertj/JadxClassNodeAssertions.java

@@ -5,8 +5,8 @@ import java.util.Map;
 import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.Assertions;
 
-import jadx.api.CodePosition;
 import jadx.api.ICodeInfo;
+import jadx.api.metadata.ICodeAnnotation;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.ICodeNode;
 import jadx.tests.api.IntegrationTest;
@@ -67,8 +67,8 @@ public class JadxClassNodeAssertions extends AbstractObjectAssert<JadxClassNodeA
 		int codePos = code.getCodeStr().indexOf(refStr);
 		assertThat(codePos).describedAs("String '%s' not found", refStr).isNotEqualTo(-1);
 		int refPos = codePos + refOffset;
-		for (Map.Entry<CodePosition, Object> entry : code.getAnnotations().entrySet()) {
+		for (Map.Entry<Integer, ICodeAnnotation> entry : code.getCodeMetadata().getAsMap().entrySet()) {
-			if (entry.getKey().getPos() == refPos) {
+			if (entry.getKey() == refPos) {
 				Assertions.assertThat(entry.getValue()).isEqualTo(node);
 				return;
 			}

jadx-core/src/test/java/jadx/tests/api/utils/assertj/JadxCodeInfoAssertions.java

@@ -5,7 +5,7 @@ import java.util.stream.Collectors;
 import org.assertj.core.api.AbstractObjectAssert;
 
 import jadx.api.ICodeInfo;
-import jadx.api.data.annotations.ICodeRawOffset;
+import jadx.api.metadata.annotations.InsnCodeOffset;
 
 import static jadx.tests.api.utils.assertj.JadxAssertions.assertThat;
 
@@ -22,9 +22,9 @@ public class JadxCodeInfoAssertions extends AbstractObjectAssert<JadxCodeInfoAss
 	}
 
 	public JadxCodeInfoAssertions checkCodeOffsets() {
-		long dupOffsetCount = actual.getAnnotations().values().stream()
+		long dupOffsetCount = actual.getCodeMetadata().getAsMap().values().stream()
-				.filter(ICodeRawOffset.class::isInstance)
+				.filter(InsnCodeOffset.class::isInstance)
-				.collect(Collectors.groupingBy(o -> ((ICodeRawOffset) o).getOffset(), Collectors.toList()))
+				.collect(Collectors.groupingBy(o -> ((InsnCodeOffset) o).getOffset(), Collectors.toList()))
 				.values().stream()
 				.filter(list -> list.size() > 1)
 				.count();

jadx-core/src/test/java/jadx/tests/external/BaseExternalTest.java

@@ -1,20 +1,19 @@
 package jadx.tests.external;
 
 import java.io.File;
-import java.util.HashMap;
-import java.util.Map;
 
-import org.apache.commons.lang3.StringUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import jadx.api.CommentsLevel;
+import jadx.api.ICodeInfo;
 import jadx.api.ICodeWriter;
 import jadx.api.JadxArgs;
 import jadx.api.JadxDecompiler;
 import jadx.api.JadxInternalAccess;
+import jadx.api.metadata.ICodeNodeRef;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.MethodNode;
 import jadx.core.dex.nodes.RootNode;
@@ -127,37 +126,15 @@ public abstract class BaseExternalTest extends IntegrationTest {
 	}
 
 	private void printMethods(ClassNode classNode, @NotNull String mthPattern) {
-		String code = classNode.getCode().getCodeStr();
+		ICodeInfo codeInfo = classNode.getCode();
+		String code = codeInfo.getCodeStr();
 		if (code == null) {
 			return;
 		}
-
 		String dashLine = "======================================================================================";
-		Map<Integer, MethodNode> methodsMap = getMethodsMap(classNode);
-		String[] lines = code.split(ICodeWriter.NL);
 		for (MethodNode mth : classNode.getMethods()) {
 			if (isMthMatch(mth, mthPattern)) {
-				int decompiledLine = mth.getDecompiledLine() - 1;
+				String mthCode = cutMethodCode(codeInfo, code, mth);
-				StringBuilder mthCode = new StringBuilder();
-				int startLine = getCommentLinesCount(lines, decompiledLine);
-				int brackets = 0;
-				for (int i = startLine; i > 0 && i < lines.length; i++) {
-					// stop if next method started
-					MethodNode mthAtLine = methodsMap.get(i);
-					if (mthAtLine != null && !mthAtLine.equals(mth)) {
-						break;
-					}
-					String line = lines[i];
-					mthCode.append(line).append(ICodeWriter.NL);
-					// also count brackets for detect method end
-					if (i >= decompiledLine) {
-						brackets += StringUtils.countMatches(line, '{');
-						brackets -= StringUtils.countMatches(line, '}');
-						if (brackets <= 0) {
-							break;
-						}
-					}
-				}
 				LOG.info("Print method: {}\n{}\n{}\n{}", mth.getMethodInfo().getShortId(),
 						dashLine,
 						mthCode,
@@ -166,22 +143,37 @@ public abstract class BaseExternalTest extends IntegrationTest {
 		}
 	}
 
-	public Map<Integer, MethodNode> getMethodsMap(ClassNode classNode) {
+	@NotNull
-		Map<Integer, MethodNode> linesMap = new HashMap<>();
+	private String cutMethodCode(ICodeInfo codeInfo, String code, MethodNode mth) {
-		for (MethodNode method : classNode.getMethods()) {
+		int defPos = mth.getDefPosition();
-			linesMap.put(method.getDecompiledLine() - 1, method);
+		int startPos = getCommentStartPos(code, defPos);
+		ICodeNodeRef nodeBelow = codeInfo.getCodeMetadata().getNodeBelow(defPos);
+		int stopPos = nodeBelow == null ? code.length() : nodeBelow.getDefPosition();
+		int brackets = 0;
+		StringBuilder mthCode = new StringBuilder();
+		for (int i = startPos; i > 0 && i < stopPos;) {
+			int codePoint = code.codePointAt(i);
+			mthCode.appendCodePoint(codePoint);
+			if (i >= defPos) {
+				// also count brackets for detect method end
+				if (codePoint == '{') {
+					brackets++;
+				} else if (codePoint == '}') {
+					brackets--;
+					if (brackets <= 0) {
+						break;
+					}
+				}
+			}
+			i += Character.charCount(codePoint);
 		}
-		return linesMap;
+		return mthCode.toString();
 	}
 
-	protected int getCommentLinesCount(String[] lines, int line) {
+	protected int getCommentStartPos(String code, int pos) {
-		for (int i = line - 1; i > 0 && i < lines.length; i--) {
+		String emptyLine = ICodeWriter.NL + ICodeWriter.NL;
-			String str = lines[i];
+		int emptyLinePos = code.lastIndexOf(emptyLine, pos);
-			if (str.isEmpty() || str.equals(ICodeWriter.NL)) {
+		return emptyLinePos == -1 ? pos : emptyLinePos + emptyLine.length();
-				return i + 1;
-			}
-		}
-		return 0;
 	}
 
 	private void printErrorReport(JadxDecompiler jadx) {

jadx-core/src/test/java/jadx/tests/integration/conditions/TestBitwiseAnd.java

@@ -8,6 +8,7 @@ import jadx.tests.api.IntegrationTest;
 import static jadx.tests.api.utils.JadxMatchers.containsOne;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+@SuppressWarnings({ "PointlessBooleanExpression", "unused" })
 public class TestBitwiseAnd extends IntegrationTest {
 
 	public static class TestCls {

jadx-core/src/test/java/jadx/tests/integration/conditions/TestConditions14.java

@@ -10,6 +10,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
 
 public class TestConditions14 extends IntegrationTest {
 
+	@SuppressWarnings({ "EqualsReplaceableByObjectsCall", "ConstantConditions" })
 	public static class TestCls {
 
 		public static boolean test(Object a, Object b) {

jadx-core/src/test/java/jadx/tests/integration/conditions/TestIfCodeStyle.java

@@ -0,0 +1,160 @@
+package jadx.tests.integration.conditions;
+
+import org.junit.jupiter.api.Test;
+
+import jadx.tests.api.SmaliTest;
+
+import static jadx.tests.api.utils.assertj.JadxAssertions.assertThat;
+
+/**
+ * Issue #1455
+ */
+public class TestIfCodeStyle extends SmaliTest {
+
+	@SuppressWarnings({ "ConstantConditions", "FieldCanBeLocal", "unused" })
+	public static class TestCls {
+
+		private String moduleName;
+		private String modulePath;
+		private String preinstalledModulePath;
+		private long versionCode;
+		private String versionName;
+		private boolean isFactory;
+		private boolean isActive;
+
+		public void test(Parcel parcel) {
+			int startPos = parcel.dataPosition();
+			int size = parcel.readInt();
+			if (size < 0) {
+				if (startPos > Integer.MAX_VALUE - size) {
+					throw new RuntimeException("Overflow in the size of parcelable");
+				}
+				parcel.setDataPosition(startPos + size);
+				return;
+			}
+			try {
+				if (parcel.dataPosition() - startPos >= size) {
+					if (startPos > Integer.MAX_VALUE - size) {
+						throw new RuntimeException("Overflow in the size of parcelable");
+					}
+					parcel.setDataPosition(startPos + size);
+					return;
+				}
+				this.moduleName = parcel.readString();
+				if (parcel.dataPosition() - startPos >= size) {
+					if (startPos > Integer.MAX_VALUE - size) {
+						throw new RuntimeException("Overflow in the size of parcelable");
+					}
+					parcel.setDataPosition(startPos + size);
+					return;
+				}
+				this.modulePath = parcel.readString();
+				if (parcel.dataPosition() - startPos >= size) {
+					if (startPos > Integer.MAX_VALUE - size) {
+						throw new RuntimeException("Overflow in the size of parcelable");
+					}
+					parcel.setDataPosition(startPos + size);
+					return;
+				}
+				this.preinstalledModulePath = parcel.readString();
+				if (parcel.dataPosition() - startPos >= size) {
+					if (startPos > Integer.MAX_VALUE - size) {
+						throw new RuntimeException("Overflow in the size of parcelable");
+					}
+					parcel.setDataPosition(startPos + size);
+					return;
+				}
+				this.versionCode = parcel.readLong();
+				if (parcel.dataPosition() - startPos >= size) {
+					if (startPos > Integer.MAX_VALUE - size) {
+						throw new RuntimeException("Overflow in the size of parcelable");
+					}
+					parcel.setDataPosition(startPos + size);
+					return;
+				}
+				this.versionName = parcel.readString();
+				if (parcel.dataPosition() - startPos >= size) {
+					if (startPos > Integer.MAX_VALUE - size) {
+						throw new RuntimeException("Overflow in the size of parcelable");
+					}
+					parcel.setDataPosition(startPos + size);
+					return;
+				}
+				this.isFactory = parcel.readInt() != 0;
+				if (parcel.dataPosition() - startPos >= size) {
+					if (startPos > Integer.MAX_VALUE - size) {
+						throw new RuntimeException("Overflow in the size of parcelable");
+					}
+					parcel.setDataPosition(startPos + size);
+					return;
+				}
+				this.isActive = parcel.readInt() != 0;
+				if (startPos > Integer.MAX_VALUE - size) {
+					throw new RuntimeException("Overflow in the size of parcelable");
+				}
+				parcel.setDataPosition(startPos + size);
+			} catch (Throwable e) {
+				if (startPos <= Integer.MAX_VALUE - size) {
+					parcel.setDataPosition(startPos + size);
+					throw e;
+				}
+				throw new RuntimeException("Overflow in the size of parcelable");
+			}
+		}
+
+		private static class Parcel {
+			public void setDataPosition(int i) {
+			}
+
+			public int dataPosition() {
+				return 0;
+			}
+
+			public int readInt() {
+				return 0;
+			}
+
+			public String readString() {
+				return null;
+			}
+
+			public long readLong() {
+				return 0;
+			}
+		}
+	}
+
+	@Test
+	public void test() {
+		noDebugInfo();
+		assertThat(getClassNode(TestCls.class))
+				.code()
+				.doesNotContain("else")
+				.countString(8, "return;")
+				.containsLines(2,
+						"if (readInt < 0) {",
+						indent() + "if (dataPosition > Integer.MAX_VALUE - readInt) {",
+						indent(2) + "throw new RuntimeException(\"Overflow in the size of parcelable\");",
+						indent() + "}",
+						indent() + "parcel.setDataPosition(dataPosition + readInt);",
+						indent() + "return;",
+						"}");
+	}
+
+	@Test
+	public void testSmali() {
+		disableCompilation();
+		assertThat(getClassNodeFromSmali())
+				.code()
+				.doesNotContain("else")
+				.countString(8, "return;")
+				.containsLines(2,
+						"if (_aidl_parcelable_size < 0) {",
+						indent() + "if (_aidl_start_pos > Integer.MAX_VALUE - _aidl_parcelable_size) {",
+						indent(2) + "throw new RuntimeException(\"Overflow in the size of parcelable\");",
+						indent() + "}",
+						indent() + "_aidl_parcel.setDataPosition(_aidl_start_pos + _aidl_parcelable_size);",
+						indent() + "return;",
+						"}");
+	}
+}

jadx-core/src/test/java/jadx/tests/integration/debuginfo/TestLineNumbers.java

@@ -2,7 +2,7 @@ package jadx.tests.integration.debuginfo;
 
 import org.junit.jupiter.api.Test;
 
-import jadx.api.ICodeWriter;
+import jadx.api.utils.CodeUtils;
 import jadx.core.dex.attributes.nodes.LineAttrNode;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.FieldNode;
@@ -42,6 +42,7 @@ public class TestLineNumbers extends IntegrationTest {
 
 	@Test
 	public void test() {
+		printLineNumbers();
 		ClassNode cls = getClassNode(TestCls.class);
 		String code = cls.getCode().toString();
 
@@ -61,19 +62,17 @@ public class TestLineNumbers extends IntegrationTest {
 		assertEquals(testClassLine + 20, innerFunc3.getSourceLine());
 
 		// check decompiled lines
-		String[] lines = code.split(ICodeWriter.NL);
+		checkLine(code, field, "int field;");
-		checkLine(lines, field, "int field;");
+		checkLine(code, func, "public void func() {");
-		checkLine(lines, func, "public void func() {");
+		checkLine(code, inner, "public static class Inner {");
-		checkLine(lines, inner, "public static class Inner {");
+		checkLine(code, innerField, "int innerField;");
-		checkLine(lines, innerField, "int innerField;");
+		checkLine(code, innerFunc, "public void innerFunc() {");
-		checkLine(lines, innerFunc, "public void innerFunc() {");
+		checkLine(code, innerFunc2, "public void innerFunc2() {");
-		checkLine(lines, innerFunc2, "public void innerFunc2() {");
+		checkLine(code, innerFunc3, "public void innerFunc3() {");
-		checkLine(lines, innerFunc3, "public void innerFunc3() {");
 	}
 
-	private static void checkLine(String[] lines, LineAttrNode node, String str) {
+	private static void checkLine(String code, LineAttrNode node, String str) {
-		int lineNumber = node.getDecompiledLine();
+		String line = CodeUtils.getLineForPos(code, node.getDefPosition());
-		String line = lines[lineNumber - 1];
 		assertThat(line, containsString(str));
 	}
 }

jadx-core/src/test/java/jadx/tests/integration/debuginfo/TestLineNumbers2.java

@@ -2,10 +2,10 @@ package jadx.tests.integration.debuginfo;
 
 import java.lang.ref.WeakReference;
 
-import org.junit.jupiter.api.Test;
-
 import jadx.core.dex.nodes.ClassNode;
 import jadx.tests.api.IntegrationTest;
+import jadx.tests.api.extensions.profiles.TestProfile;
+import jadx.tests.api.extensions.profiles.TestWithProfiles;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
@@ -32,17 +32,16 @@ public class TestLineNumbers2 extends IntegrationTest {
 		}
 	}
 
-	@Test
+	@TestWithProfiles({ TestProfile.DX_J8, TestProfile.JAVA8 })
 	public void test() {
 		printLineNumbers();
 
 		ClassNode cls = getClassNode(TestCls.class);
-		String linesMapStr = cls.getCode().getLineMapping().toString();
+		String linesMapStr = cls.getCode().getCodeMetadata().getLineMapping().toString();
 		if (isJavaInput()) {
-			assertEquals("{6=16, 9=17, 12=21, 13=22, 14=23, 16=25, 18=27, 21=30}", linesMapStr);
+			assertEquals("{6=16, 9=17, 12=21, 13=22, 14=23, 15=24, 16=25, 18=27, 21=30, 22=31}", linesMapStr);
 		} else {
-			// TODO: invert condition to match source lines
+			assertEquals("{6=16, 9=17, 12=21, 13=22, 14=23, 15=24, 16=25, 17=27, 19=27, 22=30, 23=31}", linesMapStr);
-			assertEquals("{6=16, 9=17, 12=21, 13=22, 14=23, 15=27, 17=24, 18=25, 19=27, 22=30, 23=31}", linesMapStr);
 		}
 	}
 }

jadx-core/src/test/java/jadx/tests/integration/debuginfo/TestLineNumbers3.java

@@ -33,7 +33,7 @@ public class TestLineNumbers3 extends IntegrationTest {
 	public void test() {
 		ClassNode cls = getClassNode(TestCls.class);
 		assertThat(cls).code().containsOne("super(message == null ? \"\" : message.toString());");
-		String linesMapStr = cls.getCode().getLineMapping().toString();
+		String linesMapStr = cls.getCode().getCodeMetadata().getLineMapping().toString();
 		assertThat(linesMapStr).isEqualTo("{4=13, 5=14, 6=15}");
 	}
 }

jadx-core/src/test/java/jadx/tests/integration/debuginfo/TestReturnSourceLine.java

@@ -4,6 +4,7 @@ import org.junit.jupiter.api.Test;
 
 import jadx.api.ICodeInfo;
 import jadx.api.ICodeWriter;
+import jadx.api.utils.CodeUtils;
 import jadx.core.dex.attributes.nodes.LineAttrNode;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.MethodNode;
@@ -71,9 +72,10 @@ public class TestReturnSourceLine extends IntegrationTest {
 	}
 
 	private static void checkLine(String[] lines, ICodeInfo cw, LineAttrNode node, int offset, String str) {
-		int decompiledLine = node.getDecompiledLine() + offset;
+		int nodeDefLine = CodeUtils.getLineNumForPos(cw.getCodeStr(), node.getDefPosition());
+		int decompiledLine = nodeDefLine + offset;
 		assertThat(lines[decompiledLine - 1], containsOne(str));
-		Integer sourceLine = cw.getLineMapping().get(decompiledLine);
+		Integer sourceLine = cw.getCodeMetadata().getLineMapping().get(decompiledLine);
 		assertNotNull(sourceLine);
 		assertEquals(node.getSourceLine() + offset, (int) sourceLine);
 	}

jadx-core/src/test/java/jadx/tests/integration/java8/TestLambdaExtVar.java

@@ -0,0 +1,39 @@
+package jadx.tests.integration.java8;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import jadx.core.dex.nodes.ClassNode;
+import jadx.tests.api.IntegrationTest;
+import jadx.tests.api.extensions.profiles.TestProfile;
+import jadx.tests.api.extensions.profiles.TestWithProfiles;
+
+import static jadx.tests.api.utils.assertj.JadxAssertions.assertThat;
+
+public class TestLambdaExtVar extends IntegrationTest {
+
+	public static class TestCls {
+
+		public void test(List<String> list, String str) {
+			list.removeIf(s -> s.equals(str));
+		}
+
+		public void check() {
+			List<String> list = new ArrayList<>(Arrays.asList("a", "str", "b"));
+			test(list, "str");
+			assertThat(list).isEqualTo(Arrays.asList("a", "b"));
+		}
+	}
+
+	@TestWithProfiles(TestProfile.DX_J8)
+	public void test() {
+		ClassNode cls = getClassNode(TestCls.class);
+		assertThat(cls)
+				.code()
+				.doesNotContain("lambda$")
+				.containsOne("return s.equals(str);"); // TODO: simplify to expression
+
+		System.out.println(cls.getCode().getCodeMetadata());
+	}
+}

jadx-core/src/test/java/jadx/tests/integration/loops/TestSequentialLoops.java

@@ -2,14 +2,9 @@ package jadx.tests.integration.loops;
 
 import org.junit.jupiter.api.Test;
 
-import jadx.core.dex.nodes.ClassNode;
 import jadx.tests.api.IntegrationTest;
 
-import static jadx.tests.api.utils.JadxMatchers.containsOne;
+import static jadx.tests.api.utils.assertj.JadxAssertions.assertThat;
-import static jadx.tests.api.utils.JadxMatchers.countString;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
 
 public class TestSequentialLoops extends IntegrationTest {
 
@@ -35,13 +30,10 @@ public class TestSequentialLoops extends IntegrationTest {
 
 	@Test
 	public void test() {
-		disableCompilation();
+		assertThat(getClassNode(TestCls.class))
-		ClassNode cls = getClassNode(TestCls.class);
+				.code()
-		String code = cls.getCode().toString();
+				.countString(2, "while (")
-
+				.containsOne("break;")
-		assertThat(code, countString(2, "while ("));
+				.containsOne("return c;");
-		assertThat(code, containsOne("break;"));
-		assertThat(code, containsOne("return c;"));
-		assertThat(code, not(containsString("else")));
 	}
 }

jadx-core/src/test/java/jadx/tests/integration/others/TestCodeMetadata.java

@@ -0,0 +1,66 @@
+package jadx.tests.integration.others;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import jadx.api.JadxInternalAccess;
+import jadx.api.JavaClass;
+import jadx.api.JavaMethod;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeMetadata;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.tests.api.IntegrationTest;
+
+import static jadx.tests.api.utils.assertj.JadxAssertions.assertThat;
+
+public class TestCodeMetadata extends IntegrationTest {
+
+	public static class TestCls {
+		public static class A {
+			public String str;
+		}
+
+		public String test() {
+			A a = new A();
+			a.str = call();
+			return a.str;
+		}
+
+		public static String call() {
+			return "str";
+		}
+	}
+
+	@Test
+	public void test() {
+		ClassNode cls = getClassNode(TestCls.class);
+		assertThat(cls).code().containsOne("return a.str;");
+
+		MethodNode testMth = getMethod(cls, "test");
+		MethodNode callMth = getMethod(cls, "call");
+
+		int callDefPos = callMth.getDefPosition();
+		assertThat(callDefPos).isNotZero();
+
+		JavaClass javaClass = JadxInternalAccess.convertClassNode(jadxDecompiler, cls);
+		JavaMethod callJavaMethod = JadxInternalAccess.convertMethodNode(jadxDecompiler, callMth);
+		List<Integer> callUsePlaces = javaClass.getUsePlacesFor(javaClass.getCodeInfo(), callJavaMethod);
+		assertThat(callUsePlaces).hasSize(1);
+		int callUse = callUsePlaces.get(0);
+
+		ICodeMetadata metadata = cls.getCode().getCodeMetadata();
+		ICodeNodeRef callDef = metadata.getNodeAt(callUse);
+		assertThat(callDef).isSameAs(testMth);
+
+		int beforeCallDef = callDefPos - 10;
+		ICodeAnnotation closest = metadata.getClosestUp(beforeCallDef);
+		assertThat(closest).isInstanceOf(FieldNode.class); // field reference from 'return a.str;'
+
+		ICodeNodeRef nodeBelow = metadata.getNodeBelow(beforeCallDef);
+		assertThat(nodeBelow).isSameAs(callMth);
+	}
+}

jadx-core/src/test/java/jadx/tests/integration/others/TestMoveInline.java

@@ -0,0 +1,37 @@
+package jadx.tests.integration.others;
+
+import org.junit.jupiter.api.Test;
+
+import jadx.tests.api.SmaliTest;
+
+import static jadx.tests.api.utils.assertj.JadxAssertions.assertThat;
+
+@SuppressWarnings("CommentedOutCode")
+public class TestMoveInline extends SmaliTest {
+	// @formatter:off
+	/*
+		public final void Y(int i) throws k {
+			int i2 = 0;
+			while ((i & (-128)) != 0) {
+				this.h[i2] = (byte) ((i & 127) | 128);
+				i >>>= 7;
+				i2++;
+			}
+			byte[] bArr = this.h;
+			bArr[i2] = (byte) i;
+			this.a.k(bArr, 0, i2 + 1);
+		}
+	*/
+	// @formatter:on
+
+	@Test
+	public void test() {
+		getArgs().setRawCFGOutput(true);
+		assertThat(getClassNodeFromSmali())
+				.code()
+				// check operations order
+				.containsLines(3,
+						"i >>>= 7;",
+						"i2++;");
+	}
+}

jadx-core/src/test/java/jadx/tests/integration/trycatch/TestLoopInTryCatch.java

@@ -23,7 +23,8 @@ public class TestLoopInTryCatch extends SmaliTest {
 						"        break;",
 						"    }",
 						"}",
-						"if (i == 1) {",
+						"if (i != 1) {",
+						"    getI();",
 						"}"),
 						c -> c.containsLines(2,
 								"int i;",
@@ -37,7 +38,8 @@ public class TestLoopInTryCatch extends SmaliTest {
 								"        return;",
 								"    }",
 								"}",
-								"if (i == 1) {",
+								"if (i != 1) {",
+								"    getI();",
 								"}"));
 	}
 }

jadx-core/src/test/java/jadx/tests/integration/variables/TestVariablesDeclAnnotation.java

@@ -1,12 +1,15 @@
 package jadx.tests.integration.variables;
 
-import java.util.Comparator;
+import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
 
 import org.junit.jupiter.api.Test;
 
-import jadx.api.data.annotations.VarDeclareRef;
+import jadx.api.ICodeInfo;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.api.metadata.annotations.NodeDeclareRef;
+import jadx.api.metadata.annotations.VarNode;
+import jadx.api.utils.CodeUtils;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.MethodNode;
 import jadx.tests.api.IntegrationTest;
@@ -39,14 +42,27 @@ public class TestVariablesDeclAnnotation extends IntegrationTest {
 		MethodNode testMth = cls.searchMethodByShortName(mthName);
 		assertThat(testMth).isNotNull();
 
-		int mthLine = testMth.getDecompiledLine();
+		ICodeInfo codeInfo = cls.getCode();
-		List<String> argNames = cls.getCode().getAnnotations().entrySet().stream()
+		int mthDefPos = testMth.getDefPosition();
-				.filter(e -> e.getKey().getLine() == mthLine && e.getValue() instanceof VarDeclareRef)
+		int lineEndPos = CodeUtils.getLineEndForPos(codeInfo.getCodeStr(), mthDefPos);
-				.sorted(Comparator.comparingInt(e -> e.getKey().getPos()))
+		List<String> argNames2 = new ArrayList<>();
-				.map(e -> ((VarDeclareRef) e.getValue()).getName())
+		codeInfo.getCodeMetadata().searchDown(mthDefPos, (pos, ann) -> {
-				.collect(Collectors.toList());
+			if (pos > lineEndPos) {
+				return Boolean.TRUE; // stop at line end
+			}
+			if (ann instanceof NodeDeclareRef) {
+				ICodeNodeRef declRef = ((NodeDeclareRef) ann).getNode();
+				if (declRef instanceof VarNode) {
+					VarNode varNode = (VarNode) declRef;
+					if (varNode.getMth().equals(testMth)) {
+						argNames2.add(varNode.getName());
+					}
+				}
+			}
+			return null;
+		});
 
-		assertThat(argNames).doesNotContainNull();
+		assertThat(argNames2).doesNotContainNull();
-		assertThat(argNames.toString()).isEqualTo(expectedVars);
+		assertThat(argNames2.toString()).isEqualTo(expectedVars);
 	}
 }

jadx-core/src/test/smali/conditions/TestIfCodeStyle.smali

@@ -0,0 +1,354 @@
+.class public Lconditions/TestIfCodeStyle;
+.super Ljava/lang/Object;
+.implements Landroid/os/Parcelable;
+
+
+.field public isActive:Z
+.field public isFactory:Z
+.field public moduleName:Ljava/lang/String;
+.field public modulePath:Ljava/lang/String;
+.field public preinstalledModulePath:Ljava/lang/String;
+.field public versionCode:J
+.field public versionName:Ljava/lang/String;
+
+
+.method public final readFromParcel(Landroid/os/Parcel;)V
+    .registers 9
+    .param p1, "_aidl_parcel"    # Landroid/os/Parcel;
+
+    .line 44
+    invoke-virtual {p1}, Landroid/os/Parcel;->dataPosition()I
+    move-result v0
+
+    .line 45
+    .local v0, "_aidl_start_pos":I
+    invoke-virtual {p1}, Landroid/os/Parcel;->readInt()I
+    move-result v1
+
+    .line 47
+    .local v1, "_aidl_parcelable_size":I
+    const-string v2, "Overflow in the size of parcelable"
+    const v3, 0x7fffffff
+    if-gez v1, :cond_1e
+
+    .line 63
+    sub-int/2addr v3, v1
+
+    if-gt v0, v3, :cond_18
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 47
+    return-void
+
+    .line 64
+    :cond_18
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 48
+    :cond_1e
+    :try_start_1e
+    invoke-virtual {p1}, Landroid/os/Parcel;->dataPosition()I
+
+    move-result v4
+    :try_end_22
+    .catchall {:try_start_1e .. :try_end_22} :catchall_fd
+
+    sub-int/2addr v4, v0
+
+    if-lt v4, v1, :cond_34
+
+    .line 63
+    sub-int/2addr v3, v1
+    if-gt v0, v3, :cond_2e
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 48
+    return-void
+
+    .line 64
+    :cond_2e
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 49
+    :cond_34
+    :try_start_34
+    invoke-virtual {p1}, Landroid/os/Parcel;->readString()Ljava/lang/String;
+    move-result-object v4
+
+    iput-object v4, p0, Lconditions/TestIfCodeStyle;->moduleName:Ljava/lang/String;
+
+    .line 50
+    invoke-virtual {p1}, Landroid/os/Parcel;->dataPosition()I
+    move-result v4
+    :try_end_3e
+    .catchall {:try_start_34 .. :try_end_3e} :catchall_fd
+
+    sub-int/2addr v4, v0
+
+    if-lt v4, v1, :cond_50
+
+    .line 63
+    sub-int/2addr v3, v1
+
+    if-gt v0, v3, :cond_4a
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 50
+    return-void
+
+    .line 64
+    :cond_4a
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 51
+    :cond_50
+    :try_start_50
+    invoke-virtual {p1}, Landroid/os/Parcel;->readString()Ljava/lang/String;
+    move-result-object v4
+    iput-object v4, p0, Lconditions/TestIfCodeStyle;->modulePath:Ljava/lang/String;
+
+    .line 52
+    invoke-virtual {p1}, Landroid/os/Parcel;->dataPosition()I
+    move-result v4
+
+    :try_end_5a
+    .catchall {:try_start_50 .. :try_end_5a} :catchall_fd
+
+    sub-int/2addr v4, v0
+    if-lt v4, v1, :cond_6c
+
+    .line 63
+    sub-int/2addr v3, v1
+    if-gt v0, v3, :cond_66
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 52
+    return-void
+
+    .line 64
+    :cond_66
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 53
+    :cond_6c
+    :try_start_6c
+    invoke-virtual {p1}, Landroid/os/Parcel;->readString()Ljava/lang/String;
+    move-result-object v4
+    iput-object v4, p0, Lconditions/TestIfCodeStyle;->preinstalledModulePath:Ljava/lang/String;
+
+    .line 54
+    invoke-virtual {p1}, Landroid/os/Parcel;->dataPosition()I
+    move-result v4
+
+    :try_end_76
+    .catchall {:try_start_6c .. :try_end_76} :catchall_fd
+
+    sub-int/2addr v4, v0
+    if-lt v4, v1, :cond_88
+
+    .line 63
+    sub-int/2addr v3, v1
+    if-gt v0, v3, :cond_82
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 54
+    return-void
+
+    .line 64
+    :cond_82
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 55
+    :cond_88
+    :try_start_88
+    invoke-virtual {p1}, Landroid/os/Parcel;->readLong()J
+    move-result-wide v4
+    iput-wide v4, p0, Lconditions/TestIfCodeStyle;->versionCode:J
+
+    .line 56
+    invoke-virtual {p1}, Landroid/os/Parcel;->dataPosition()I
+    move-result v4
+
+    :try_end_92
+    .catchall {:try_start_88 .. :try_end_92} :catchall_fd
+
+    sub-int/2addr v4, v0
+    if-lt v4, v1, :cond_a4
+
+    .line 63
+    sub-int/2addr v3, v1
+    if-gt v0, v3, :cond_9e
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 56
+    return-void
+
+    .line 64
+    :cond_9e
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 57
+    :cond_a4
+    :try_start_a4
+    invoke-virtual {p1}, Landroid/os/Parcel;->readString()Ljava/lang/String;
+    move-result-object v4
+    iput-object v4, p0, Lconditions/TestIfCodeStyle;->versionName:Ljava/lang/String;
+
+    .line 58
+    invoke-virtual {p1}, Landroid/os/Parcel;->dataPosition()I
+    move-result v4
+    :try_end_ae
+    .catchall {:try_start_a4 .. :try_end_ae} :catchall_fd
+
+    sub-int/2addr v4, v0
+    if-lt v4, v1, :cond_c0
+
+    .line 63
+    sub-int/2addr v3, v1
+    if-gt v0, v3, :cond_ba
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 58
+    return-void
+
+    .line 64
+    :cond_ba
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 59
+    :cond_c0
+    :try_start_c0
+    invoke-virtual {p1}, Landroid/os/Parcel;->readInt()I
+    move-result v4
+    const/4 v5, 0x1
+    const/4 v6, 0x0
+    if-eqz v4, :cond_ca
+    move v4, v5
+    goto :goto_cb
+
+    :cond_ca
+    move v4, v6
+
+    :goto_cb
+    iput-boolean v4, p0, Lconditions/TestIfCodeStyle;->isFactory:Z
+
+    .line 60
+    invoke-virtual {p1}, Landroid/os/Parcel;->dataPosition()I
+
+    move-result v4
+    :try_end_d1
+    .catchall {:try_start_c0 .. :try_end_d1} :catchall_fd
+
+    sub-int/2addr v4, v0
+    if-lt v4, v1, :cond_e3
+
+    .line 63
+    sub-int/2addr v3, v1
+
+    if-gt v0, v3, :cond_dd
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 60
+    return-void
+
+    .line 64
+    :cond_dd
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 61
+    :cond_e3
+    :try_start_e3
+    invoke-virtual {p1}, Landroid/os/Parcel;->readInt()I
+    move-result v4
+
+    if-eqz v4, :cond_ea
+    goto :goto_eb
+
+    :cond_ea
+    move v5, v6
+
+    :goto_eb
+    iput-boolean v5, p0, Lconditions/TestIfCodeStyle;->isActive:Z
+    :try_end_ed
+    .catchall {:try_start_e3 .. :try_end_ed} :catchall_fd
+
+    .line 63
+    sub-int/2addr v3, v1
+
+    if-gt v0, v3, :cond_f7
+
+    .line 66
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 67
+    nop
+
+    .line 68
+    return-void
+
+    .line 64
+    :cond_f7
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 63
+    :catchall_fd
+    move-exception v4
+    sub-int/2addr v3, v1
+    if-le v0, v3, :cond_107
+
+    .line 64
+    new-instance v3, Ljava/lang/RuntimeException;
+    invoke-direct {v3, v2}, Ljava/lang/RuntimeException;-><init>(Ljava/lang/String;)V
+    throw v3
+
+    .line 66
+    :cond_107
+    add-int v2, v0, v1
+    invoke-virtual {p1, v2}, Landroid/os/Parcel;->setDataPosition(I)V
+
+    .line 67
+    throw v4
+.end method

jadx-core/src/test/smali/others/TestMoveInline.smali

@@ -0,0 +1,44 @@
+.class public Lothers/TestMoveInline;
+.super Ljava/lang/Object;
+
+.field private h:[B
+.field private a:Lothers/TestMoveInline;
+
+.method public k([BII)V
+    .registers 5
+    return-void
+.end method
+
+.method public test(I)V
+    .registers 7
+
+    const/4 v0, 0x0
+    move v1, v0
+
+    :goto_2
+    and-int/lit8 v2, p1, -0x80
+    if-nez v2, :cond_13
+
+    .line 1
+    iget-object v2, p0, Lothers/TestMoveInline;->h:[B
+    add-int/lit8 v3, v1, 0x1
+    int-to-byte p1, p1
+    aput-byte p1, v2, v1
+
+    .line 2
+    iget-object p1, p0, Lothers/TestMoveInline;->a:Lothers/TestMoveInline;
+    invoke-virtual {p1, v2, v0, v3}, Lothers/TestMoveInline;->k([BII)V
+    return-void
+
+    .line 3
+    :cond_13
+    iget-object v2, p0, Lothers/TestMoveInline;->h:[B
+    add-int/lit8 v3, v1, 0x1
+    and-int/lit8 v4, p1, 0x7f
+    or-int/lit16 v4, v4, 0x80
+    int-to-byte v4, v4
+    aput-byte v4, v2, v1
+    ushr-int/lit8 p1, p1, 0x7
+    move v1, v3
+    goto :goto_2
+.end method

jadx-core/src/test/smali/trycatch/TestLoopInTryCatch.smali

@@ -24,7 +24,7 @@
 
     :cond
     if-eq v1, v2, :end
-
+	invoke-static {}, Ltrycatch/TestLoopInTryCatch;->getI()I
     return-void
 
     :try_end

jadx-gui/build.gradle

@@ -16,9 +16,9 @@ dependencies {
 	implementation files('libs/jfontchooser-1.0.5.jar')
 	implementation 'hu.kazocsaba:image-viewer:1.2.3'
 
-	implementation 'com.formdev:flatlaf:2.1'
+	implementation 'com.formdev:flatlaf:2.3'
-	implementation 'com.formdev:flatlaf-intellij-themes:2.1'
+	implementation 'com.formdev:flatlaf-intellij-themes:2.3'
-	implementation 'com.formdev:flatlaf-extras:2.1'
+	implementation 'com.formdev:flatlaf-extras:2.3'
 	implementation 'com.formdev:svgSalamander:1.1.3'
 
 	implementation 'com.google.code.gson:gson:2.9.0'
@@ -29,6 +29,8 @@ dependencies {
 	implementation "com.github.akarnokd:rxjava2-swing:0.3.7"
 	implementation 'com.android.tools.build:apksig:4.2.1'
 	implementation 'io.github.hqktech:jdwp:1.0'
+
+	testImplementation project(":jadx-core").sourceSets.test.output
 }
 
 application {
@@ -98,7 +100,6 @@ runtime {
 	addModules(
 			'java.desktop',
 			'java.naming',
-			'java.sql', // TODO: GSON register adapter for java.sql.Time
 			'java.xml',
 	)
 	jpackage {
@@ -111,10 +112,9 @@ runtime {
 	}
 }
 
-task distWinWithJre(type: Zip, dependsOn: ['runtime', 'createExe']) {
+task copyDistWinWithJre(type: Copy, dependsOn: ['runtime', 'createExe']) {
 	group 'jadx'
-	destinationDirectory = buildDir
+	destinationDir = new File(buildDir, "jadx-gui-${jadxVersion}-with-jre-win")
-	archiveFileName = "jadx-gui-${jadxVersion}-with-jre-win.zip"
 	from(runtime.jreDir) {
 		include '**/*'
 		into 'jre'
@@ -124,3 +124,13 @@ task distWinWithJre(type: Zip, dependsOn: ['runtime', 'createExe']) {
 	}
 	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
 }
+
+task distWinWithJre(type: Zip, dependsOn: ['copyDistWinWithJre']) {
+	group 'jadx'
+	destinationDirectory = buildDir
+	archiveFileName = "jadx-gui-${jadxVersion}-with-jre-win.zip"
+	from(copyDistWinWithJre.outputs) {
+		include '**/*'
+	}
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}