Merge pull request #468 from Vineflower/develop/1.11.1

Release 1.11.1

Author: jaskarth

build.gradle

@@ -58,7 +58,7 @@ allprojects {
 group = 'org.vineflower'
 base.archivesName = 'vineflower'
 
-version = '1.11.0'
+version = '1.11.1'
 
 def ENV = System.getenv()
 version = version + (ENV.GITHUB_ACTIONS ? "" : "+local")

src/org/jetbrains/java/decompiler/modules/decompiler/SwitchPatternMatchProcessor.java

@@ -187,7 +187,7 @@ private static boolean processStatement(SwitchStatement stat, Statement root) {
             if (assign.getLeft() instanceof VarExprent) {
               VarExprent var = (VarExprent) assign.getLeft();
 
-              if (assign.getRight() instanceof FunctionExprent && ((FunctionExprent) assign.getRight()).getFuncType() == FunctionExprent.FunctionType.CAST) {
+              if (isPatternMatchingCastAssignment(head, assign)) {
                 FunctionExprent cast = (FunctionExprent) assign.getRight();
 
                 List<Exprent> operands = new ArrayList<>();
@@ -547,4 +547,19 @@ private static boolean isSwitchPatternMatch(SwitchHeadExprent head) {
   public static boolean hasPatternMatch(RootStatement root) {
     return root.mt.getBytecodeVersion().hasSwitchPatternMatch() && DecompilerContext.getOption(IFernflowerPreferences.PATTERN_MATCHING);
   }
+
+  private static boolean isPatternMatchingCastAssignment(final SwitchHeadExprent switchHead, final AssignmentExprent assignment) {
+    if (!(assignment.getRight() instanceof final FunctionExprent functionExprent)) return false;
+    if (functionExprent.getFuncType() != FunctionType.CAST) return false;
+
+    final List<Exprent> lstOperands = functionExprent.getLstOperands();
+    // We expect the assignment to be a literal `n = (Type) m`.
+    // Any other operands are not allowed in simple pattern matching.
+    if (lstOperands.size() < 2) return false;
+    if (!(lstOperands.get(0) instanceof final VarExprent switchHeadRef)) return false;
+    if (!(lstOperands.get(1) instanceof final ConstExprent castTypeRef)) return false;
+    if (!switchHead.containsVar(switchHeadRef.getVarVersionPair())) return false; // Not the switch head var ref
+
+    return true;
+  }
 }

src/org/jetbrains/java/decompiler/modules/decompiler/exps/InvocationExprent.java

@@ -307,7 +307,7 @@ else if (!bounds.containsKey(from)) {
                     }
                   }
 
-                  if (ok && isMappingInBounds(from, to, named, bounds)) {
+                  if (ok && isMappingInBounds(from, to, named, bounds, new HashSet<>())) {
                     upperBoundsMap.put(from, to);
                   }
                 }
@@ -1421,6 +1421,16 @@ private BitSet getAmbiguousParameters(List<StructMethod> matches) {
             ((FunctionExprent) exp).setNeedsCast(true);
           }
 
+          if (i == md.params.length - 1 && mt.hasModifier(CodeConstants.ACC_VARARGS)) {
+            if (exp instanceof NewExprent newE && newE.getExprType().arrayDim > 0) {
+              for (Exprent entry : newE.getLstArrayElements()) {
+                if (entry instanceof FunctionExprent func && func.getSimpleCastType() != null) {
+                  func.setNeedsCast(true);
+                }
+              }
+            }
+          }
+
           // Check if the current parameters and method descriptor are of the same type, or if the descriptor's type is a superset of the parameter's type.
           // This check ensures that parameters that can be safely passed don't have an unneeded cast on them, such as System.out.println((int)5);.
           // TODO: The root cause of the above issue seems to be threading related- When debugging line by line it doesn't cast, but when running normally it does. More digging needs to be done to figure out why this happens.
@@ -1560,12 +1570,12 @@ private boolean processGenericMapping(VarType from, VarType to, Map<VarType, Lis
   }
 
   private void putGenericMapping(VarType from, VarType to, Map<VarType, List<VarType>> named, Map<VarType, List<VarType>> bounds) {
-    if (isMappingInBounds(from, to, named, bounds)) {
+    if (isMappingInBounds(from, to, named, bounds, new HashSet<>())) {
       genericsMap.put(from, to);
     }
   }
 
-  private boolean isMappingInBounds(VarType from, VarType to, Map<VarType, List<VarType>> named, Map<VarType, List<VarType>> bounds) {
+  private boolean isMappingInBounds(VarType from, VarType to, Map<VarType, List<VarType>> named, Map<VarType, List<VarType>> bounds, Set<Pair<VarType, VarType>> recursivelySeen) {
     if (!bounds.containsKey(from)) {
       return false;
     }
@@ -1602,7 +1612,11 @@ private boolean isMappingInBounds(VarType from, VarType to, Map<VarType, List<Va
           }
         }
 
-        return isMappingInBounds(bound, newTo, named, bounds);
+        Pair<VarType, VarType> pair = Pair.of(bound, newTo);
+        if (!recursivelySeen.contains(pair)) {
+          recursivelySeen.add(pair);
+          return isMappingInBounds(bound, newTo, named, bounds, recursivelySeen);
+        }
       }
 
       if (newTo.type.ordinal() < CodeType.OBJECT.ordinal()) {
@@ -1644,9 +1658,15 @@ private boolean isMappingInBounds(VarType from, VarType to, Map<VarType, List<Va
             }
 
             // T extends Comparable<S>, S extends Object
-            if (bounds.containsKey(boundArg) && isMappingInBounds(boundArg, newArg, named, bounds)) {
-              toAdd.put(boundArg, newArg);
-              continue;
+            if (bounds.containsKey(boundArg)) {
+              Pair<VarType, VarType> pair = Pair.of(bound, newTo);
+              if (!recursivelySeen.contains(pair)) {
+                recursivelySeen.add(pair);
+                if (isMappingInBounds(boundArg, newArg, named, bounds, recursivelySeen)) {
+                  toAdd.put(boundArg, newArg);
+                  continue;
+                }
+              }
             }
             return false;
           }

src/org/jetbrains/java/decompiler/modules/decompiler/exps/SwitchExprent.java

@@ -15,7 +15,7 @@
 
 public class SwitchExprent extends Exprent {
   private final SwitchStatement backing;
-  private final VarType type;
+  private VarType type;
   // TODO: is needed?
   private final boolean fallthrough;
   // Whether the switch expression returns a value, for case type coercion
@@ -222,6 +222,10 @@ private static boolean isSyntheticThrowEdge(StatEdge edge){
     return false;
   }
 
+  public void setType(VarType type) {
+    this.type = type;
+  }
+
   @Override
   public int getPrecedence() {
     return 1; // Should enclose in case of invocation

src/org/jetbrains/java/decompiler/modules/decompiler/vars/VarDefinitionHelper.java

@@ -1452,18 +1452,22 @@ public void remapClashingNames(Statement root, StructMethod mt) {
       start += (md.params[i].stackSize - 1);
     }
 
-    iterateClashingNames(root, mt, varDefinitions, liveVarDefs, nameMap);
+    Set<String> seenMethods = new HashSet<>();
+    seenMethods.add(InterpreterUtil.makeUniqueKey(mt.getName(), mt.getDescriptor()));
+
+    iterateClashingNames(root, mt, varDefinitions, liveVarDefs, nameMap, seenMethods);
   }
 
-  private void iterateClashingNames(Statement stat, StructMethod mt, Map<Statement, Set<VarInMethod>> varDefinitions, Set<VarInMethod> liveVarDefs, Map<VarInMethod, String> nameMap) {
+  private void iterateClashingNames(Statement stat, StructMethod mt, Map<Statement, Set<VarInMethod>> varDefinitions,
+                                    Set<VarInMethod> liveVarDefs, Map<VarInMethod, String> nameMap, Set<String> seenMethods) {
     Set<VarInMethod> curVarDefs = new HashSet<>();
 
     boolean shouldRemoveAtEnd = false;
 
     // Process var definitions as owned by the parent- they come before the statement, and so their scope extends past the actual statement.
     for (Exprent exprent : stat.getVarDefinitions()) {
       Set<VarInMethod> upDefs = new HashSet<>();
-      iterateClashingExprent(stat, mt, varDefinitions, exprent, liveVarDefs, upDefs, nameMap);
+      iterateClashingExprent(stat, mt, varDefinitions, exprent, liveVarDefs, upDefs, nameMap, seenMethods);
       liveVarDefs.addAll(upDefs);
       varDefinitions.put(stat.getParent(), upDefs);
     }
@@ -1474,7 +1478,7 @@ private void iterateClashingNames(Statement stat, StructMethod mt, Map<Statement
       BasicBlockStatement basic = stat.getBasichead();
       for (Exprent exprent : basic.getExprents()) {
         for (Exprent ex : exprent.getAllExprents(true, true)) {
-          iterateClashingExprent(basic, mt, varDefinitions, ex, liveVarDefs, upDefs, nameMap);
+          iterateClashingExprent(basic, mt, varDefinitions, ex, liveVarDefs, upDefs, nameMap, seenMethods);
         }
       }
 
@@ -1489,7 +1493,7 @@ private void iterateClashingNames(Statement stat, StructMethod mt, Map<Statement
           // Sort order from getAllExprents here is crucial!
           // Say, for example, "MyType t = method(t -> ....);"
           // It is imperative that the lhs of the assign comes first, so that any defs in the rhs can be properly seen.
-          iterateClashingExprent(stat, mt, varDefinitions, ex, liveVarDefs, curVarDefs, nameMap);
+          iterateClashingExprent(stat, mt, varDefinitions, ex, liveVarDefs, curVarDefs, nameMap, seenMethods);
         }
       }
     } else {
@@ -1499,7 +1503,7 @@ private void iterateClashingNames(Statement stat, StructMethod mt, Map<Statement
           List<Exprent> exprents = ((Exprent) obj).getAllExprents(true, true);
 
           for (Exprent exprent : exprents) {
-            iterateClashingExprent(stat, mt, varDefinitions, exprent, liveVarDefs, curVarDefs, nameMap);
+            iterateClashingExprent(stat, mt, varDefinitions, exprent, liveVarDefs, curVarDefs, nameMap, seenMethods);
           }
         }
       }
@@ -1538,7 +1542,7 @@ private void iterateClashingNames(Statement stat, StructMethod mt, Map<Statement
           }
         }
 
-        iterateClashingNames(st, mt, varDefinitions, liveVarDefs, nameMap);
+        iterateClashingNames(st, mt, varDefinitions, liveVarDefs, nameMap, seenMethods);
       }
     }
 
@@ -1555,7 +1559,7 @@ private void iterateClashingNames(Statement stat, StructMethod mt, Map<Statement
     // Process deferred statements
     if (iterate) {
       for (Statement st : deferred) {
-        iterateClashingNames(st, mt, varDefinitions, liveVarDefs, nameMap);
+        iterateClashingNames(st, mt, varDefinitions, liveVarDefs, nameMap, seenMethods);
       }
     }
 
@@ -1575,7 +1579,8 @@ private void clearStatement(Map<Statement, Set<VarInMethod>> varDefinitions, Set
     }
   }
 
-  private void iterateClashingExprent(Statement stat, StructMethod mt, Map<Statement, Set<VarInMethod>> varDefinitions, Exprent exprent, Set<VarInMethod> liveVarDefs, Set<VarInMethod> curVarDefs, Map<VarInMethod, String> nameMap) {
+  private void iterateClashingExprent(Statement stat, StructMethod mt, Map<Statement, Set<VarInMethod>> varDefinitions, Exprent exprent,
+                                      Set<VarInMethod> liveVarDefs, Set<VarInMethod> curVarDefs, Map<VarInMethod, String> nameMap, Set<String> seenMethods) {
     if (exprent instanceof NewExprent) {
       NewExprent newExprent = (NewExprent) exprent;
       // Check if this is a lambda with a body
@@ -1584,7 +1589,8 @@ private void iterateClashingExprent(Statement stat, StructMethod mt, Map<Stateme
         if (node != null && node.getWrapper() != null) {
           MethodWrapper mw = node.getWrapper().getMethods().getWithKey(node.lambdaInformation.content_method_key);
           StructMethod mt2 = node.getWrapper().getClassStruct().getMethod(node.lambdaInformation.content_method_key);
-          if (mt2 != null && mw != null) {
+          if (mt2 != null && mw != null && !seenMethods.contains(InterpreterUtil.makeUniqueKey(mt2.getName(), mt2.getDescriptor()))) {
+            seenMethods.add(InterpreterUtil.makeUniqueKey(mt2.getName(), mt2.getDescriptor()));
             // Propagate current data through to lambda
             VarDefinitionHelper vardef = new VarDefinitionHelper(mw.root, mt2, mw.varproc, false);
 
@@ -1616,7 +1622,7 @@ private void iterateClashingExprent(Statement stat, StructMethod mt, Map<Stateme
             }
 
             // Iterate clashing names with the lambda's body, with the context of the outer method
-            vardef.iterateClashingNames(mw.root, mt2, varDefinitions, liveVarDefs, nameMap);
+            vardef.iterateClashingNames(mw.root, mt2, varDefinitions, liveVarDefs, nameMap, seenMethods);
 
             for (Entry<VarVersionPair, String> e : vardef.getClashingNames().entrySet()) {
               mw.varproc.setClashingName(e.getKey(), e.getValue());
@@ -1636,7 +1642,8 @@ private void iterateClashingExprent(Statement stat, StructMethod mt, Map<Stateme
           for (String mthKey : node.getWrapper().getMethods().getLstKeys()) {
             MethodWrapper mw = node.getWrapper().getMethods().getWithKey(mthKey);
             StructMethod mt2 = node.getWrapper().getClassStruct().getMethod(mthKey);
-            if (mt2 != null && mw != null && !mt2.hasModifier(CodeConstants.ACC_SYNTHETIC)) {
+            if (mt2 != null && mw != null && !mt2.hasModifier(CodeConstants.ACC_SYNTHETIC) && !seenMethods.contains(InterpreterUtil.makeUniqueKey(mt2.getName(), mt2.getDescriptor()))) {
+              seenMethods.add(InterpreterUtil.makeUniqueKey(mt2.getName(), mt2.getDescriptor()));
               // Propagate current data through to method
               VarDefinitionHelper vardef = new VarDefinitionHelper(mw.root, mt2, mw.varproc, false);
 
@@ -1669,7 +1676,7 @@ private void iterateClashingExprent(Statement stat, StructMethod mt, Map<Stateme
               }
 
               // Iterate clashing names with the lambda's body, with the context of the outer method
-              vardef.iterateClashingNames(mw.root, mt2, varDefinitions, liveVarDefs, nameMap);
+              vardef.iterateClashingNames(mw.root, mt2, varDefinitions, liveVarDefs, nameMap, seenMethods);
 
               for (Entry<VarVersionPair, String> e : vardef.getClashingNames().entrySet()) {
                 mw.varproc.setClashingName(e.getKey(), e.getValue());

src/org/jetbrains/java/decompiler/modules/decompiler/vars/VarTypeProcessor.java

@@ -182,6 +182,8 @@ else if (newType.typeFamily == TypeFamily.INTEGER) {
 
       case FUNCTION:
         return changeFunctionExprentType(newType, minMax, (FunctionExprent)exprent);
+      case SWITCH:
+        return changeSwitchExprentType(newType, minMax, (SwitchExprent) exprent);
     }
 
     return true;
@@ -237,6 +239,16 @@ private boolean changeFunctionExprentType(VarType newType, int minMax, FunctionE
     return true;
   }
 
+  private boolean changeSwitchExprentType(VarType newType, int minMax, SwitchExprent switchExpr) {
+    if (minMax == 1) { // max
+      VarType type = switchExpr.getExprType();
+      if (newType.typeFamily == TypeFamily.INTEGER && type.typeFamily == newType.typeFamily) {
+        switchExpr.setType(newType);
+      }
+    }
+    return true;
+  }
+
   public Map<VarVersionPair, VarType> getMapExprentMaxTypes() {
     return mapExprentMaxTypes;
   }

src/org/jetbrains/java/decompiler/struct/StructClass.java

@@ -213,7 +213,7 @@ public ConstantPool getPool() {
     if (recordAttr == null) {
       // If our class extends j.l.Record but also has no components, it's probably malformed.
       // Force processing as a record anyway, in the hopes that we can come to a better result.
-      if (this.superClass.getString().equals("java/lang/Record")) {
+      if (this.superClass != null && this.superClass.getString().equals("java/lang/Record")) {
         return new ArrayList<>();
       }
 

test/org/jetbrains/java/decompiler/SingleClassesTest.java

@@ -715,6 +715,9 @@ private void registerDefault() {
     register(JAVA_8, "TestCatchVariable");
     register(JAVA_8, "TestExtraneousImports");
     register(JAVA_17, "TestSwitchOnEnumFake");
+    register(JAVA_16, "TestSwitchExpressionReturnType");
+    register(JAVA_8, "TestGenericMapping");
+
   }
 
   private void registerEntireClassPath() {

testData/results/pkg/TestGenericMapping.dec

@@ -0,0 +1,36 @@
+package pkg;
+
+public class TestGenericMapping {
+   class EntityA<Q extends TestGenericMapping.EntityA<Q, R>, R extends TestGenericMapping.EntityB<Q, R>> {
+      public void doSomething(Q q) {
+      }// 6
+   }
+
+   public class EntityB<S extends TestGenericMapping.EntityA<S, T>, T extends TestGenericMapping.EntityB<S, T>> {
+      public void doSomething(S t) {
+         t.doSomething(t);// 11
+      }// 12
+   }
+}
+
+class 'pkg/TestGenericMapping$EntityA' {
+   method 'doSomething (Lpkg/TestGenericMapping$EntityA;)V' {
+      0      5
+   }
+}
+
+class 'pkg/TestGenericMapping$EntityB' {
+   method 'doSomething (Lpkg/TestGenericMapping$EntityA;)V' {
+      0      10
+      1      10
+      2      10
+      3      10
+      4      10
+      5      11
+   }
+}
+
+Lines mapping:
+6 <-> 6
+11 <-> 11
+12 <-> 12