Use pattern variables.

fniephaus · fniephaus · commit f40a76e66bd0 · 2025-08-04T16:40:23.000+02:00
diff --git a/wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/Linker.java b/wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/Linker.java
@@ -1048,10 +1048,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof ExportGlobalSym)) {
+                if (!(object instanceof ExportGlobalSym that)) {
                     return false;
                 }
-                final ExportGlobalSym that = (ExportGlobalSym) object;
                 return this.moduleName.equals(that.moduleName) && this.globalName.equals(that.globalName);
             }
         }
@@ -1076,10 +1075,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof InitializeGlobalSym)) {
+                if (!(object instanceof InitializeGlobalSym that)) {
                     return false;
                 }
-                final InitializeGlobalSym that = (InitializeGlobalSym) object;
                 return this.globalIndex == that.globalIndex && this.moduleName.equals(that.moduleName);
             }
         }
@@ -1139,10 +1137,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof ExportFunctionSym)) {
+                if (!(object instanceof ExportFunctionSym that)) {
                     return false;
                 }
-                final ExportFunctionSym that = (ExportFunctionSym) object;
                 return this.moduleName.equals(that.moduleName) && this.functionName.equals(that.functionName);
             }
         }
@@ -1170,10 +1167,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof ImportMemorySym)) {
+                if (!(object instanceof ImportMemorySym that)) {
                     return false;
                 }
-                final ImportMemorySym that = (ImportMemorySym) object;
                 return this.moduleName.equals(that.moduleName) && this.importDescriptor.equals(that.importDescriptor) && this.memoryIndex == that.memoryIndex;
             }
         }
@@ -1198,10 +1194,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof ExportMemorySym)) {
+                if (!(object instanceof ExportMemorySym that)) {
                     return false;
                 }
-                final ExportMemorySym that = (ExportMemorySym) object;
                 return this.moduleName.equals(that.moduleName) && this.memoryName.equals(that.memoryName);
             }
         }
@@ -1226,10 +1221,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof DataSym)) {
+                if (!(object instanceof DataSym that)) {
                     return false;
                 }
-                final DataSym that = (DataSym) object;
                 return this.dataSegmentId == that.dataSegmentId && this.moduleName.equals(that.moduleName);
             }
         }
@@ -1254,10 +1248,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof ImportTableSym)) {
+                if (!(object instanceof ImportTableSym that)) {
                     return false;
                 }
-                final ImportTableSym that = (ImportTableSym) object;
                 return this.moduleName.equals(that.moduleName) && this.importDescriptor.equals(that.importDescriptor);
             }
         }
@@ -1282,10 +1275,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof ExportTableSym)) {
+                if (!(object instanceof ExportTableSym that)) {
                     return false;
                 }
-                final ExportTableSym that = (ExportTableSym) object;
                 return this.moduleName.equals(that.moduleName) && this.tableName.equals(that.tableName);
             }
         }
@@ -1310,10 +1302,9 @@ public int hashCode() {
 
             @Override
             public boolean equals(Object object) {
-                if (!(object instanceof ElemSym)) {
+                if (!(object instanceof ElemSym that)) {
                     return false;
                 }
-                final ElemSym that = (ElemSym) object;
                 return this.elemSegmentId == that.elemSegmentId && this.moduleName.equals(that.moduleName);
             }
         }
diff --git a/wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/api/WebAssembly.java b/wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/api/WebAssembly.java
@@ -432,13 +432,12 @@ public WasmTable tableAlloc(int initial, int maximum, TableKind elemKind, Object
 
     private static Object tableGrow(Object[] args) {
         checkArgumentCount(args, 2);
-        if (!(args[0] instanceof WasmTable)) {
+        if (!(args[0] instanceof WasmTable table)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm table");
         }
         if (!(args[1] instanceof Integer)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be integer");
         }
-        WasmTable table = (WasmTable) args[0];
         int delta = (Integer) args[1];
         if (args.length > 2) {
             return tableGrow(table, delta, args[2]);
@@ -456,13 +455,12 @@ public static int tableGrow(WasmTable table, int delta, Object ref) {
 
     private static Object tableRead(Object[] args) {
         checkArgumentCount(args, 2);
-        if (!(args[0] instanceof WasmTable)) {
+        if (!(args[0] instanceof WasmTable table)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm table");
         }
         if (!(args[1] instanceof Integer)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be integer");
         }
-        WasmTable table = (WasmTable) args[0];
         int index = (Integer) args[1];
         return tableRead(table, index);
     }
@@ -477,13 +475,12 @@ public static Object tableRead(WasmTable table, int index) {
 
     private Object tableWrite(Object[] args) {
         checkArgumentCount(args, 3);
-        if (!(args[0] instanceof WasmTable)) {
+        if (!(args[0] instanceof WasmTable table)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm table");
         }
         if (!(args[1] instanceof Integer)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be integer");
         }
-        WasmTable table = (WasmTable) args[0];
         int index = (Integer) args[1];
         return tableWrite(table, index, args[2]);
     }
@@ -515,10 +512,9 @@ public Object tableWrite(WasmTable table, int index, Object element) {
 
     private static Object tableSize(Object[] args) {
         checkArgumentCount(args, 1);
-        if (!(args[0] instanceof WasmTable)) {
+        if (!(args[0] instanceof WasmTable table)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm table");
         }
-        WasmTable table = (WasmTable) args[0];
         return tableSize(table);
     }
 
@@ -613,13 +609,12 @@ public static WasmMemory memAlloc(int initial, int maximum, boolean shared) {
 
     private static Object memGrow(Object[] args) {
         checkArgumentCount(args, 2);
-        if (!(args[0] instanceof WasmMemory)) {
+        if (!(args[0] instanceof WasmMemory memory)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm memory");
         }
         if (!(args[1] instanceof Integer)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be integer");
         }
-        WasmMemory memory = (WasmMemory) args[0];
         int delta = (Integer) args[1];
         return memGrow(memory, delta);
     }
@@ -818,10 +813,9 @@ public WasmGlobal globalAlloc(ValueType valueType, boolean mutable, Object value
 
     private static Object globalRead(Object[] args) {
         checkArgumentCount(args, 1);
-        if (!(args[0] instanceof WasmGlobal)) {
+        if (!(args[0] instanceof WasmGlobal global)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm global");
         }
-        WasmGlobal global = (WasmGlobal) args[0];
         return globalRead(global);
     }
 
@@ -845,10 +839,9 @@ public static Object globalRead(WasmGlobal global) {
 
     private Object globalWrite(Object[] args) {
         checkArgumentCount(args, 2);
-        if (!(args[0] instanceof WasmGlobal)) {
+        if (!(args[0] instanceof WasmGlobal global)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm global");
         }
-        WasmGlobal global = (WasmGlobal) args[0];
         return globalWrite(global, args[1]);
     }
 
@@ -904,14 +897,12 @@ public Object globalWrite(WasmGlobal global, Object value) {
 
     private static Object instanceExport(Object[] args) {
         checkArgumentCount(args, 2);
-        if (!(args[0] instanceof WasmInstance)) {
+        if (!(args[0] instanceof WasmInstance instance)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm instance");
         }
-        if (!(args[1] instanceof String)) {
+        if (!(args[1] instanceof String name)) {
             throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be string");
         }
-        WasmInstance instance = (WasmInstance) args[0];
-        String name = (String) args[1];
         return instanceExport(instance, name);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1048,10 +1048,9 @@ public int hashCode() {`
`1048`	`1048`
`1049`	`1049`	`@Override`
`1050`	`1050`	`public boolean equals(Object object) {`
`1051`		`- if (!(object instanceof ExportGlobalSym)) {`
	`1051`	`+ if (!(object instanceof ExportGlobalSym that)) {`
`1052`	`1052`	`return false;`
`1053`	`1053`	`}`
`1054`		`- final ExportGlobalSym that = (ExportGlobalSym) object;`
`1055`	`1054`	`return this.moduleName.equals(that.moduleName) && this.globalName.equals(that.globalName);`
`1056`	`1055`	`}`
`1057`	`1056`	`}`
`@@ -1076,10 +1075,9 @@ public int hashCode() {`
`1076`	`1075`
`1077`	`1076`	`@Override`
`1078`	`1077`	`public boolean equals(Object object) {`
`1079`		`- if (!(object instanceof InitializeGlobalSym)) {`
	`1078`	`+ if (!(object instanceof InitializeGlobalSym that)) {`
`1080`	`1079`	`return false;`
`1081`	`1080`	`}`
`1082`		`- final InitializeGlobalSym that = (InitializeGlobalSym) object;`
`1083`	`1081`	`return this.globalIndex == that.globalIndex && this.moduleName.equals(that.moduleName);`
`1084`	`1082`	`}`
`1085`	`1083`	`}`
`@@ -1139,10 +1137,9 @@ public int hashCode() {`
`1139`	`1137`
`1140`	`1138`	`@Override`
`1141`	`1139`	`public boolean equals(Object object) {`
`1142`		`- if (!(object instanceof ExportFunctionSym)) {`
	`1140`	`+ if (!(object instanceof ExportFunctionSym that)) {`
`1143`	`1141`	`return false;`
`1144`	`1142`	`}`
`1145`		`- final ExportFunctionSym that = (ExportFunctionSym) object;`
`1146`	`1143`	`return this.moduleName.equals(that.moduleName) && this.functionName.equals(that.functionName);`
`1147`	`1144`	`}`
`1148`	`1145`	`}`
`@@ -1170,10 +1167,9 @@ public int hashCode() {`
`1170`	`1167`
`1171`	`1168`	`@Override`
`1172`	`1169`	`public boolean equals(Object object) {`
`1173`		`- if (!(object instanceof ImportMemorySym)) {`
	`1170`	`+ if (!(object instanceof ImportMemorySym that)) {`
`1174`	`1171`	`return false;`
`1175`	`1172`	`}`
`1176`		`- final ImportMemorySym that = (ImportMemorySym) object;`
`1177`	`1173`	`return this.moduleName.equals(that.moduleName) && this.importDescriptor.equals(that.importDescriptor) && this.memoryIndex == that.memoryIndex;`
`1178`	`1174`	`}`
`1179`	`1175`	`}`
`@@ -1198,10 +1194,9 @@ public int hashCode() {`
`1198`	`1194`
`1199`	`1195`	`@Override`
`1200`	`1196`	`public boolean equals(Object object) {`
`1201`		`- if (!(object instanceof ExportMemorySym)) {`
	`1197`	`+ if (!(object instanceof ExportMemorySym that)) {`
`1202`	`1198`	`return false;`
`1203`	`1199`	`}`
`1204`		`- final ExportMemorySym that = (ExportMemorySym) object;`
`1205`	`1200`	`return this.moduleName.equals(that.moduleName) && this.memoryName.equals(that.memoryName);`
`1206`	`1201`	`}`
`1207`	`1202`	`}`
`@@ -1226,10 +1221,9 @@ public int hashCode() {`
`1226`	`1221`
`1227`	`1222`	`@Override`
`1228`	`1223`	`public boolean equals(Object object) {`
`1229`		`- if (!(object instanceof DataSym)) {`
	`1224`	`+ if (!(object instanceof DataSym that)) {`
`1230`	`1225`	`return false;`
`1231`	`1226`	`}`
`1232`		`- final DataSym that = (DataSym) object;`
`1233`	`1227`	`return this.dataSegmentId == that.dataSegmentId && this.moduleName.equals(that.moduleName);`
`1234`	`1228`	`}`
`1235`	`1229`	`}`
`@@ -1254,10 +1248,9 @@ public int hashCode() {`
`1254`	`1248`
`1255`	`1249`	`@Override`
`1256`	`1250`	`public boolean equals(Object object) {`
`1257`		`- if (!(object instanceof ImportTableSym)) {`
	`1251`	`+ if (!(object instanceof ImportTableSym that)) {`
`1258`	`1252`	`return false;`
`1259`	`1253`	`}`
`1260`		`- final ImportTableSym that = (ImportTableSym) object;`
`1261`	`1254`	`return this.moduleName.equals(that.moduleName) && this.importDescriptor.equals(that.importDescriptor);`
`1262`	`1255`	`}`
`1263`	`1256`	`}`
`@@ -1282,10 +1275,9 @@ public int hashCode() {`
`1282`	`1275`
`1283`	`1276`	`@Override`
`1284`	`1277`	`public boolean equals(Object object) {`
`1285`		`- if (!(object instanceof ExportTableSym)) {`
	`1278`	`+ if (!(object instanceof ExportTableSym that)) {`
`1286`	`1279`	`return false;`
`1287`	`1280`	`}`
`1288`		`- final ExportTableSym that = (ExportTableSym) object;`
`1289`	`1281`	`return this.moduleName.equals(that.moduleName) && this.tableName.equals(that.tableName);`
`1290`	`1282`	`}`
`1291`	`1283`	`}`
`@@ -1310,10 +1302,9 @@ public int hashCode() {`
`1310`	`1302`
`1311`	`1303`	`@Override`
`1312`	`1304`	`public boolean equals(Object object) {`
`1313`		`- if (!(object instanceof ElemSym)) {`
	`1305`	`+ if (!(object instanceof ElemSym that)) {`
`1314`	`1306`	`return false;`
`1315`	`1307`	`}`
`1316`		`- final ElemSym that = (ElemSym) object;`
`1317`	`1308`	`return this.elemSegmentId == that.elemSegmentId && this.moduleName.equals(that.moduleName);`
`1318`	`1309`	`}`
`1319`	`1310`	`}`
Original file line number	Diff line number	Diff line change
`@@ -432,13 +432,12 @@ public WasmTable tableAlloc(int initial, int maximum, TableKind elemKind, Object`
`432`	`432`
`433`	`433`	`private static Object tableGrow(Object[] args) {`
`434`	`434`	`checkArgumentCount(args, 2);`
`435`		`- if (!(args[0] instanceof WasmTable)) {`
	`435`	`+ if (!(args[0] instanceof WasmTable table)) {`
`436`	`436`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm table");`
`437`	`437`	`}`
`438`	`438`	`if (!(args[1] instanceof Integer)) {`
`439`	`439`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be integer");`
`440`	`440`	`}`
`441`		`- WasmTable table = (WasmTable) args[0];`
`442`	`441`	`int delta = (Integer) args[1];`
`443`	`442`	`if (args.length > 2) {`
`444`	`443`	`return tableGrow(table, delta, args[2]);`
`@@ -456,13 +455,12 @@ public static int tableGrow(WasmTable table, int delta, Object ref) {`
`456`	`455`
`457`	`456`	`private static Object tableRead(Object[] args) {`
`458`	`457`	`checkArgumentCount(args, 2);`
`459`		`- if (!(args[0] instanceof WasmTable)) {`
	`458`	`+ if (!(args[0] instanceof WasmTable table)) {`
`460`	`459`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm table");`
`461`	`460`	`}`
`462`	`461`	`if (!(args[1] instanceof Integer)) {`
`463`	`462`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be integer");`
`464`	`463`	`}`
`465`		`- WasmTable table = (WasmTable) args[0];`
`466`	`464`	`int index = (Integer) args[1];`
`467`	`465`	`return tableRead(table, index);`
`468`	`466`	`}`
`@@ -477,13 +475,12 @@ public static Object tableRead(WasmTable table, int index) {`
`477`	`475`
`478`	`476`	`private Object tableWrite(Object[] args) {`
`479`	`477`	`checkArgumentCount(args, 3);`
`480`		`- if (!(args[0] instanceof WasmTable)) {`
	`478`	`+ if (!(args[0] instanceof WasmTable table)) {`
`481`	`479`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm table");`
`482`	`480`	`}`
`483`	`481`	`if (!(args[1] instanceof Integer)) {`
`484`	`482`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be integer");`
`485`	`483`	`}`
`486`		`- WasmTable table = (WasmTable) args[0];`
`487`	`484`	`int index = (Integer) args[1];`
`488`	`485`	`return tableWrite(table, index, args[2]);`
`489`	`486`	`}`
`@@ -515,10 +512,9 @@ public Object tableWrite(WasmTable table, int index, Object element) {`
`515`	`512`
`516`	`513`	`private static Object tableSize(Object[] args) {`
`517`	`514`	`checkArgumentCount(args, 1);`
`518`		`- if (!(args[0] instanceof WasmTable)) {`
	`515`	`+ if (!(args[0] instanceof WasmTable table)) {`
`519`	`516`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm table");`
`520`	`517`	`}`
`521`		`- WasmTable table = (WasmTable) args[0];`
`522`	`518`	`return tableSize(table);`
`523`	`519`	`}`
`524`	`520`
`@@ -613,13 +609,12 @@ public static WasmMemory memAlloc(int initial, int maximum, boolean shared) {`
`613`	`609`
`614`	`610`	`private static Object memGrow(Object[] args) {`
`615`	`611`	`checkArgumentCount(args, 2);`
`616`		`- if (!(args[0] instanceof WasmMemory)) {`
	`612`	`+ if (!(args[0] instanceof WasmMemory memory)) {`
`617`	`613`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm memory");`
`618`	`614`	`}`
`619`	`615`	`if (!(args[1] instanceof Integer)) {`
`620`	`616`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be integer");`
`621`	`617`	`}`
`622`		`- WasmMemory memory = (WasmMemory) args[0];`
`623`	`618`	`int delta = (Integer) args[1];`
`624`	`619`	`return memGrow(memory, delta);`
`625`	`620`	`}`
`@@ -818,10 +813,9 @@ public WasmGlobal globalAlloc(ValueType valueType, boolean mutable, Object value`
`818`	`813`
`819`	`814`	`private static Object globalRead(Object[] args) {`
`820`	`815`	`checkArgumentCount(args, 1);`
`821`		`- if (!(args[0] instanceof WasmGlobal)) {`
	`816`	`+ if (!(args[0] instanceof WasmGlobal global)) {`
`822`	`817`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm global");`
`823`	`818`	`}`
`824`		`- WasmGlobal global = (WasmGlobal) args[0];`
`825`	`819`	`return globalRead(global);`
`826`	`820`	`}`
`827`	`821`
`@@ -845,10 +839,9 @@ public static Object globalRead(WasmGlobal global) {`
`845`	`839`
`846`	`840`	`private Object globalWrite(Object[] args) {`
`847`	`841`	`checkArgumentCount(args, 2);`
`848`		`- if (!(args[0] instanceof WasmGlobal)) {`
	`842`	`+ if (!(args[0] instanceof WasmGlobal global)) {`
`849`	`843`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm global");`
`850`	`844`	`}`
`851`		`- WasmGlobal global = (WasmGlobal) args[0];`
`852`	`845`	`return globalWrite(global, args[1]);`
`853`	`846`	`}`
`854`	`847`
`@@ -904,14 +897,12 @@ public Object globalWrite(WasmGlobal global, Object value) {`
`904`	`897`
`905`	`898`	`private static Object instanceExport(Object[] args) {`
`906`	`899`	`checkArgumentCount(args, 2);`
`907`		`- if (!(args[0] instanceof WasmInstance)) {`
	`900`	`+ if (!(args[0] instanceof WasmInstance instance)) {`
`908`	`901`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "First argument must be wasm instance");`
`909`	`902`	`}`
`910`		`- if (!(args[1] instanceof String)) {`
	`903`	`+ if (!(args[1] instanceof String name)) {`
`911`	`904`	`throw new WasmJsApiException(WasmJsApiException.Kind.TypeError, "Second argument must be string");`
`912`	`905`	`}`
`913`		`- WasmInstance instance = (WasmInstance) args[0];`
`914`		`- String name = (String) args[1];`
`915`	`906`	`return instanceExport(instance, name);`
`916`	`907`	`}`
`917`	`908`