summaryrefslogtreecommitdiff
path: root/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/java/cuchaz/enigma/mapping/ClassMapping.java')
-rw-r--r--src/main/java/cuchaz/enigma/mapping/ClassMapping.java163
1 files changed, 87 insertions, 76 deletions
diff --git a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
index 51751ca..c782250 100644
--- a/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
+++ b/src/main/java/cuchaz/enigma/mapping/ClassMapping.java
@@ -34,7 +34,6 @@ public class ClassMapping implements Comparable<ClassMapping> {
34 private Map<String, MethodMapping> methodsByDeobf; 34 private Map<String, MethodMapping> methodsByDeobf;
35 private boolean isDirty; 35 private boolean isDirty;
36 private Mappings.EntryModifier modifier; 36 private Mappings.EntryModifier modifier;
37 private boolean deobfInner;
38 37
39 public ClassMapping(String obfFullName) { 38 public ClassMapping(String obfFullName) {
40 this(obfFullName, null, Mappings.EntryModifier.UNCHANGED); 39 this(obfFullName, null, Mappings.EntryModifier.UNCHANGED);
@@ -81,6 +80,10 @@ public class ClassMapping implements Comparable<ClassMapping> {
81 return deobfName; 80 return deobfName;
82 } 81 }
83 82
83 public String getTranslatedName(TranslationDirection direction) {
84 return direction.choose(deobfName, obfFullName);
85 }
86
84 //// INNER CLASSES //////// 87 //// INNER CLASSES ////////
85 88
86 public void setDeobfName(String val) { 89 public void setDeobfName(String val) {
@@ -191,21 +194,21 @@ public class ClassMapping implements Comparable<ClassMapping> {
191 return fieldsByObf.values(); 194 return fieldsByObf.values();
192 } 195 }
193 196
194 public boolean containsObfField(String obfName, Type obfType) { 197 public boolean containsObfField(String obfName, TypeDescriptor obfDesc) {
195 return fieldsByObf.containsKey(getFieldKey(obfName, obfType)); 198 return fieldsByObf.containsKey(getFieldKey(obfName, obfDesc));
196 } 199 }
197 200
198 public boolean containsDeobfField(String deobfName, Type deobfType) { 201 public boolean containsDeobfField(String deobfName, TypeDescriptor deobfDesc) {
199 return fieldsByDeobf.containsKey(getFieldKey(deobfName, deobfType)); 202 return fieldsByDeobf.containsKey(getFieldKey(deobfName, deobfDesc));
200 } 203 }
201 204
202 public void addFieldMapping(FieldMapping fieldMapping) { 205 public void addFieldMapping(FieldMapping fieldMapping) {
203 String obfKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType()); 206 String obfKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfDesc());
204 if (fieldsByObf.containsKey(obfKey)) { 207 if (fieldsByObf.containsKey(obfKey)) {
205 throw new Error("Already have mapping for " + obfFullName + "." + obfKey); 208 throw new Error("Already have mapping for " + obfFullName + "." + obfKey);
206 } 209 }
207 if (fieldMapping.getDeobfName() != null) { 210 if (fieldMapping.getDeobfName() != null) {
208 String deobfKey = getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType()); 211 String deobfKey = getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfDesc());
209 if (fieldsByDeobf.containsKey(deobfKey)) { 212 if (fieldsByDeobf.containsKey(deobfKey)) {
210 throw new Error("Already have mapping for " + deobfName + "." + deobfKey); 213 throw new Error("Already have mapping for " + deobfName + "." + deobfKey);
211 } 214 }
@@ -218,63 +221,67 @@ public class ClassMapping implements Comparable<ClassMapping> {
218 } 221 }
219 222
220 public void removeFieldMapping(FieldMapping fieldMapping) { 223 public void removeFieldMapping(FieldMapping fieldMapping) {
221 boolean obfWasRemoved = fieldsByObf.remove(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType())) != null; 224 boolean obfWasRemoved = fieldsByObf.remove(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfDesc())) != null;
222 assert (obfWasRemoved); 225 assert (obfWasRemoved);
223 if (fieldMapping.getDeobfName() != null) { 226 if (fieldMapping.getDeobfName() != null) {
224 boolean deobfWasRemoved = fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfType())) != null; 227 boolean deobfWasRemoved = fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), fieldMapping.getObfDesc())) != null;
225 assert (deobfWasRemoved); 228 assert (deobfWasRemoved);
226 } 229 }
227 this.isDirty = true; 230 this.isDirty = true;
228 } 231 }
229 232
230 public FieldMapping getFieldByObf(String obfName, Type obfType) { 233 public FieldMapping getFieldByObf(String obfName, TypeDescriptor obfDesc) {
231 return fieldsByObf.get(getFieldKey(obfName, obfType)); 234 return fieldsByObf.get(getFieldKey(obfName, obfDesc));
235 }
236
237 public FieldMapping getFieldByObf(FieldEntry field) {
238 return getFieldByObf(field.getName(), field.getDesc());
232 } 239 }
233 240
234 public FieldMapping getFieldByDeobf(String deobfName, Type obfType) { 241 public FieldMapping getFieldByDeobf(String deobfName, TypeDescriptor obfDesc) {
235 return fieldsByDeobf.get(getFieldKey(deobfName, obfType)); 242 return fieldsByDeobf.get(getFieldKey(deobfName, obfDesc));
236 } 243 }
237 244
238 public String getObfFieldName(String deobfName, Type obfType) { 245 public String getObfFieldName(String deobfName, TypeDescriptor obfDesc) {
239 FieldMapping fieldMapping = fieldsByDeobf.get(getFieldKey(deobfName, obfType)); 246 FieldMapping fieldMapping = fieldsByDeobf.get(getFieldKey(deobfName, obfDesc));
240 if (fieldMapping != null) { 247 if (fieldMapping != null) {
241 return fieldMapping.getObfName(); 248 return fieldMapping.getObfName();
242 } 249 }
243 return null; 250 return null;
244 } 251 }
245 252
246 public String getDeobfFieldName(String obfName, Type obfType) { 253 public String getDeobfFieldName(String obfName, TypeDescriptor obfDesc) {
247 FieldMapping fieldMapping = fieldsByObf.get(getFieldKey(obfName, obfType)); 254 FieldMapping fieldMapping = fieldsByObf.get(getFieldKey(obfName, obfDesc));
248 if (fieldMapping != null) { 255 if (fieldMapping != null) {
249 return fieldMapping.getDeobfName(); 256 return fieldMapping.getDeobfName();
250 } 257 }
251 return null; 258 return null;
252 } 259 }
253 260
254 private String getFieldKey(String name, Type type) { 261 private String getFieldKey(String name, TypeDescriptor desc) {
255 if (name == null) { 262 if (name == null) {
256 throw new IllegalArgumentException("name cannot be null!"); 263 throw new IllegalArgumentException("name cannot be null!");
257 } 264 }
258 if (type == null) { 265 if (desc == null) {
259 throw new IllegalArgumentException("type cannot be null!"); 266 throw new IllegalArgumentException("desc cannot be null!");
260 } 267 }
261 return name + ":" + type; 268 return name + ":" + desc;
262 } 269 }
263 270
264 public void setFieldName(String obfName, Type obfType, String deobfName) { 271 public void setFieldName(String obfName, TypeDescriptor obfDesc, String deobfName) {
265 assert (deobfName != null); 272 assert (deobfName != null);
266 FieldMapping fieldMapping = fieldsByObf.get(getFieldKey(obfName, obfType)); 273 FieldMapping fieldMapping = fieldsByObf.get(getFieldKey(obfName, obfDesc));
267 if (fieldMapping == null) { 274 if (fieldMapping == null) {
268 fieldMapping = new FieldMapping(obfName, obfType, deobfName, Mappings.EntryModifier.UNCHANGED); 275 fieldMapping = new FieldMapping(obfName, obfDesc, deobfName, Mappings.EntryModifier.UNCHANGED);
269 boolean obfWasAdded = fieldsByObf.put(getFieldKey(obfName, obfType), fieldMapping) == null; 276 boolean obfWasAdded = fieldsByObf.put(getFieldKey(obfName, obfDesc), fieldMapping) == null;
270 assert (obfWasAdded); 277 assert (obfWasAdded);
271 } else { 278 } else {
272 boolean wasRemoved = fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), obfType)) != null; 279 boolean wasRemoved = fieldsByDeobf.remove(getFieldKey(fieldMapping.getDeobfName(), obfDesc)) != null;
273 assert (wasRemoved); 280 assert (wasRemoved);
274 } 281 }
275 fieldMapping.setDeobfName(deobfName); 282 fieldMapping.setDeobfName(deobfName);
276 if (deobfName != null) { 283 if (deobfName != null) {
277 boolean wasAdded = fieldsByDeobf.put(getFieldKey(deobfName, obfType), fieldMapping) == null; 284 boolean wasAdded = fieldsByDeobf.put(getFieldKey(deobfName, obfDesc), fieldMapping) == null;
278 assert (wasAdded); 285 assert (wasAdded);
279 } 286 }
280 this.isDirty = true; 287 this.isDirty = true;
@@ -282,13 +289,13 @@ public class ClassMapping implements Comparable<ClassMapping> {
282 289
283 //// METHODS //////// 290 //// METHODS ////////
284 291
285 public void setFieldObfNameAndType(String oldObfName, Type obfType, String newObfName, Type newObfType) { 292 public void setFieldObfNameAndType(String oldObfName, TypeDescriptor obfDesc, String newObfName, TypeDescriptor newObfDesc) {
286 assert (newObfName != null); 293 assert (newObfName != null);
287 FieldMapping fieldMapping = fieldsByObf.remove(getFieldKey(oldObfName, obfType)); 294 FieldMapping fieldMapping = fieldsByObf.remove(getFieldKey(oldObfName, obfDesc));
288 assert (fieldMapping != null); 295 assert (fieldMapping != null);
289 fieldMapping.setObfName(newObfName); 296 fieldMapping.setObfName(newObfName);
290 fieldMapping.setObfType(newObfType); 297 fieldMapping.setObfDesc(newObfDesc);
291 boolean obfWasAdded = fieldsByObf.put(getFieldKey(newObfName, newObfType), fieldMapping) == null; 298 boolean obfWasAdded = fieldsByObf.put(getFieldKey(newObfName, newObfDesc), fieldMapping) == null;
292 assert (obfWasAdded); 299 assert (obfWasAdded);
293 this.isDirty = true; 300 this.isDirty = true;
294 } 301 }
@@ -298,23 +305,23 @@ public class ClassMapping implements Comparable<ClassMapping> {
298 return methodsByObf.values(); 305 return methodsByObf.values();
299 } 306 }
300 307
301 public boolean containsObfMethod(String obfName, Signature obfSignature) { 308 public boolean containsObfMethod(String obfName, MethodDescriptor obfDescriptor) {
302 return methodsByObf.containsKey(getMethodKey(obfName, obfSignature)); 309 return methodsByObf.containsKey(getMethodKey(obfName, obfDescriptor));
303 } 310 }
304 311
305 public boolean containsDeobfMethod(String deobfName, Signature obfSignature) { 312 public boolean containsDeobfMethod(String deobfName, MethodDescriptor obfDescriptor) {
306 return methodsByDeobf.containsKey(getMethodKey(deobfName, obfSignature)); 313 return methodsByDeobf.containsKey(getMethodKey(deobfName, obfDescriptor));
307 } 314 }
308 315
309 public void addMethodMapping(MethodMapping methodMapping) { 316 public void addMethodMapping(MethodMapping methodMapping) {
310 String obfKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()); 317 String obfKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfDesc());
311 if (methodsByObf.containsKey(obfKey)) { 318 if (methodsByObf.containsKey(obfKey)) {
312 throw new Error("Already have mapping for " + obfFullName + "." + obfKey); 319 throw new Error("Already have mapping for " + obfFullName + "." + obfKey);
313 } 320 }
314 boolean wasAdded = methodsByObf.put(obfKey, methodMapping) == null; 321 boolean wasAdded = methodsByObf.put(obfKey, methodMapping) == null;
315 assert (wasAdded); 322 assert (wasAdded);
316 if (methodMapping.getDeobfName() != null) { 323 if (methodMapping.getDeobfName() != null) {
317 String deobfKey = getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature()); 324 String deobfKey = getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfDesc());
318 if (methodsByDeobf.containsKey(deobfKey)) { 325 if (methodsByDeobf.containsKey(deobfKey)) {
319 throw new Error("Already have mapping for " + deobfName + "." + deobfKey); 326 throw new Error("Already have mapping for " + deobfName + "." + deobfKey);
320 } 327 }
@@ -326,44 +333,48 @@ public class ClassMapping implements Comparable<ClassMapping> {
326 } 333 }
327 334
328 public void removeMethodMapping(MethodMapping methodMapping) { 335 public void removeMethodMapping(MethodMapping methodMapping) {
329 boolean obfWasRemoved = methodsByObf.remove(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature())) != null; 336 boolean obfWasRemoved = methodsByObf.remove(getMethodKey(methodMapping.getObfName(), methodMapping.getObfDesc())) != null;
330 assert (obfWasRemoved); 337 assert (obfWasRemoved);
331 if (methodMapping.getDeobfName() != null) { 338 if (methodMapping.getDeobfName() != null) {
332 boolean deobfWasRemoved = methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null; 339 boolean deobfWasRemoved = methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfDesc())) != null;
333 assert (deobfWasRemoved); 340 assert (deobfWasRemoved);
334 } 341 }
335 this.isDirty = true; 342 this.isDirty = true;
336 } 343 }
337 344
338 public MethodMapping getMethodByObf(String obfName, Signature obfSignature) { 345 public MethodMapping getMethodByObf(String obfName, MethodDescriptor obfDescriptor) {
339 return methodsByObf.get(getMethodKey(obfName, obfSignature)); 346 return methodsByObf.get(getMethodKey(obfName, obfDescriptor));
347 }
348
349 public MethodMapping getMethodByObf(MethodEntry method) {
350 return getMethodByObf(method.getName(), method.getDesc());
340 } 351 }
341 352
342 public MethodMapping getMethodByDeobf(String deobfName, Signature obfSignature) { 353 public MethodMapping getMethodByDeobf(String deobfName, MethodDescriptor obfDescriptor) {
343 return methodsByDeobf.get(getMethodKey(deobfName, obfSignature)); 354 return methodsByDeobf.get(getMethodKey(deobfName, obfDescriptor));
344 } 355 }
345 356
346 private String getMethodKey(String name, Signature signature) { 357 private String getMethodKey(String name, MethodDescriptor descriptor) {
347 if (name == null) { 358 if (name == null) {
348 throw new IllegalArgumentException("name cannot be null!"); 359 throw new IllegalArgumentException("name cannot be null!");
349 } 360 }
350 if (signature == null) { 361 if (descriptor == null) {
351 throw new IllegalArgumentException("signature cannot be null!"); 362 throw new IllegalArgumentException("descriptor cannot be null!");
352 } 363 }
353 return name + signature; 364 return name + descriptor;
354 } 365 }
355 366
356 public void setMethodName(String obfName, Signature obfSignature, String deobfName) { 367 public void setMethodName(String obfName, MethodDescriptor obfDescriptor, String deobfName) {
357 MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfName, obfSignature)); 368 MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfName, obfDescriptor));
358 if (methodMapping == null) { 369 if (methodMapping == null) {
359 methodMapping = createMethodMapping(obfName, obfSignature); 370 methodMapping = createMethodMapping(obfName, obfDescriptor);
360 } else if (methodMapping.getDeobfName() != null) { 371 } else if (methodMapping.getDeobfName() != null) {
361 boolean wasRemoved = methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfSignature())) != null; 372 boolean wasRemoved = methodsByDeobf.remove(getMethodKey(methodMapping.getDeobfName(), methodMapping.getObfDesc())) != null;
362 assert (wasRemoved); 373 assert (wasRemoved);
363 } 374 }
364 methodMapping.setDeobfName(deobfName); 375 methodMapping.setDeobfName(deobfName);
365 if (deobfName != null) { 376 if (deobfName != null) {
366 boolean wasAdded = methodsByDeobf.put(getMethodKey(deobfName, obfSignature), methodMapping) == null; 377 boolean wasAdded = methodsByDeobf.put(getMethodKey(deobfName, obfDescriptor), methodMapping) == null;
367 assert (wasAdded); 378 assert (wasAdded);
368 } 379 }
369 this.isDirty = true; 380 this.isDirty = true;
@@ -371,35 +382,35 @@ public class ClassMapping implements Comparable<ClassMapping> {
371 382
372 //// ARGUMENTS //////// 383 //// ARGUMENTS ////////
373 384
374 public void setMethodObfNameAndSignature(String oldObfName, Signature obfSignature, String newObfName, Signature newObfSignature) { 385 public void setMethodObfNameAndSignature(String oldObfName, MethodDescriptor obfDescriptor, String newObfName, MethodDescriptor newObfDescriptor) {
375 assert (newObfName != null); 386 assert (newObfName != null);
376 MethodMapping methodMapping = methodsByObf.remove(getMethodKey(oldObfName, obfSignature)); 387 MethodMapping methodMapping = methodsByObf.remove(getMethodKey(oldObfName, obfDescriptor));
377 assert (methodMapping != null); 388 assert (methodMapping != null);
378 methodMapping.setObfName(newObfName); 389 methodMapping.setObfName(newObfName);
379 methodMapping.setObfSignature(newObfSignature); 390 methodMapping.setObfDescriptor(newObfDescriptor);
380 boolean obfWasAdded = methodsByObf.put(getMethodKey(newObfName, newObfSignature), methodMapping) == null; 391 boolean obfWasAdded = methodsByObf.put(getMethodKey(newObfName, newObfDescriptor), methodMapping) == null;
381 assert (obfWasAdded); 392 assert (obfWasAdded);
382 this.isDirty = true; 393 this.isDirty = true;
383 } 394 }
384 395
385 public void setArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex, String argumentName) { 396 public void setArgumentName(String obfMethodName, MethodDescriptor obfMethodDescriptor, int argumentIndex, String argumentName) {
386 assert (argumentName != null); 397 assert (argumentName != null);
387 MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)); 398 MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfMethodName, obfMethodDescriptor));
388 if (methodMapping == null) { 399 if (methodMapping == null) {
389 methodMapping = createMethodMapping(obfMethodName, obfMethodSignature); 400 methodMapping = createMethodMapping(obfMethodName, obfMethodDescriptor);
390 } 401 }
391 methodMapping.setArgumentName(argumentIndex, argumentName); 402 methodMapping.setLocalVariableName(argumentIndex, argumentName);
392 this.isDirty = true; 403 this.isDirty = true;
393 } 404 }
394 405
395 public void removeArgumentName(String obfMethodName, Signature obfMethodSignature, int argumentIndex) { 406 public void removeArgumentName(String obfMethodName, MethodDescriptor obfMethodDescriptor, int argumentIndex) {
396 methodsByObf.get(getMethodKey(obfMethodName, obfMethodSignature)).removeArgumentName(argumentIndex); 407 methodsByObf.get(getMethodKey(obfMethodName, obfMethodDescriptor)).removeLocalVariableName(argumentIndex);
397 this.isDirty = true; 408 this.isDirty = true;
398 } 409 }
399 410
400 private MethodMapping createMethodMapping(String obfName, Signature obfSignature) { 411 private MethodMapping createMethodMapping(String obfName, MethodDescriptor obfDescriptor) {
401 MethodMapping methodMapping = new MethodMapping(obfName, obfSignature); 412 MethodMapping methodMapping = new MethodMapping(obfName, obfDescriptor);
402 boolean wasAdded = methodsByObf.put(getMethodKey(obfName, obfSignature), methodMapping) == null; 413 boolean wasAdded = methodsByObf.put(getMethodKey(obfName, obfDescriptor), methodMapping) == null;
403 assert (wasAdded); 414 assert (wasAdded);
404 this.isDirty = true; 415 this.isDirty = true;
405 return methodMapping; 416 return methodMapping;
@@ -459,24 +470,24 @@ public class ClassMapping implements Comparable<ClassMapping> {
459 470
460 // rename field types 471 // rename field types
461 for (FieldMapping fieldMapping : new ArrayList<>(fieldsByObf.values())) { 472 for (FieldMapping fieldMapping : new ArrayList<>(fieldsByObf.values())) {
462 String oldFieldKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType()); 473 String oldFieldKey = getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfDesc());
463 if (fieldMapping.renameObfClass(oldObfClassName, newObfClassName)) { 474 if (fieldMapping.renameObfClass(oldObfClassName, newObfClassName)) {
464 boolean wasRemoved = fieldsByObf.remove(oldFieldKey) != null; 475 boolean wasRemoved = fieldsByObf.remove(oldFieldKey) != null;
465 assert (wasRemoved); 476 assert (wasRemoved);
466 boolean wasAdded = fieldsByObf 477 boolean wasAdded = fieldsByObf
467 .put(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfType()), fieldMapping) == null; 478 .put(getFieldKey(fieldMapping.getObfName(), fieldMapping.getObfDesc()), fieldMapping) == null;
468 assert (wasAdded); 479 assert (wasAdded);
469 } 480 }
470 } 481 }
471 482
472 // rename method signatures 483 // rename method signatures
473 for (MethodMapping methodMapping : new ArrayList<>(methodsByObf.values())) { 484 for (MethodMapping methodMapping : new ArrayList<>(methodsByObf.values())) {
474 String oldMethodKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()); 485 String oldMethodKey = getMethodKey(methodMapping.getObfName(), methodMapping.getObfDesc());
475 if (methodMapping.renameObfClass(oldObfClassName, newObfClassName)) { 486 if (methodMapping.renameObfClass(oldObfClassName, newObfClassName)) {
476 boolean wasRemoved = methodsByObf.remove(oldMethodKey) != null; 487 boolean wasRemoved = methodsByObf.remove(oldMethodKey) != null;
477 assert (wasRemoved); 488 assert (wasRemoved);
478 boolean wasAdded = methodsByObf 489 boolean wasAdded = methodsByObf
479 .put(getMethodKey(methodMapping.getObfName(), methodMapping.getObfSignature()), methodMapping) == null; 490 .put(getMethodKey(methodMapping.getObfName(), methodMapping.getObfDesc()), methodMapping) == null;
480 assert (wasAdded); 491 assert (wasAdded);
481 } 492 }
482 } 493 }
@@ -490,9 +501,9 @@ public class ClassMapping implements Comparable<ClassMapping> {
490 return false; 501 return false;
491 } 502 }
492 503
493 public boolean containsArgument(BehaviorEntry obfBehaviorEntry, String name) { 504 public boolean containsArgument(MethodEntry obfMethodEntry, String name) {
494 MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfBehaviorEntry.getName(), obfBehaviorEntry.getSignature())); 505 MethodMapping methodMapping = methodsByObf.get(getMethodKey(obfMethodEntry.getName(), obfMethodEntry.getDesc()));
495 return methodMapping != null && methodMapping.containsArgument(name); 506 return methodMapping != null && methodMapping.containsLocalVariable(name);
496 } 507 }
497 508
498 public ClassEntry getObfEntry() { 509 public ClassEntry getObfEntry() {
@@ -521,9 +532,9 @@ public class ClassMapping implements Comparable<ClassMapping> {
521 this.modifier = modifier; 532 this.modifier = modifier;
522 } 533 }
523 534
524 public void setFieldModifier(String obfName, Type obfType, Mappings.EntryModifier modifier) { 535 public void setFieldModifier(String obfName, TypeDescriptor obfDesc, Mappings.EntryModifier modifier) {
525 FieldMapping fieldMapping = fieldsByObf.computeIfAbsent(getFieldKey(obfName, obfType), 536 FieldMapping fieldMapping = fieldsByObf.computeIfAbsent(getFieldKey(obfName, obfDesc),
526 k -> new FieldMapping(obfName, obfType, null, Mappings.EntryModifier.UNCHANGED)); 537 k -> new FieldMapping(obfName, obfDesc, null, Mappings.EntryModifier.UNCHANGED));
527 538
528 if (fieldMapping.getModifier() != modifier) { 539 if (fieldMapping.getModifier() != modifier) {
529 fieldMapping.setModifier(modifier); 540 fieldMapping.setModifier(modifier);
@@ -531,7 +542,7 @@ public class ClassMapping implements Comparable<ClassMapping> {
531 } 542 }
532 } 543 }
533 544
534 public void setMethodModifier(String obfName, Signature sig, Mappings.EntryModifier modifier) { 545 public void setMethodModifier(String obfName, MethodDescriptor sig, Mappings.EntryModifier modifier) {
535 MethodMapping methodMapping = methodsByObf.computeIfAbsent(getMethodKey(obfName, sig), 546 MethodMapping methodMapping = methodsByObf.computeIfAbsent(getMethodKey(obfName, sig),
536 k -> new MethodMapping(obfName, sig, null, Mappings.EntryModifier.UNCHANGED)); 547 k -> new MethodMapping(obfName, sig, null, Mappings.EntryModifier.UNCHANGED));
537 548
HIC SVNT DRACONES